Use the Datadog HTTP API to programmatically access the Datadog platform.
To get started on Datadog HTTP API, use our Datadog Postman collection
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.
SIGNATURE:
https://api.datadoghq.com/api/https://api.datadoghq.eu/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.
Note: All Datadog API Clients are configured by default to consume Datadog US site APIs. If you are on the Datadog EU site, Set the environment variable DATADOG_HOST to https://api.datadoghq.eu or overide this value directly when creating your Client.
EXAMPLE:
from datadog import initialize, api
options = {'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>',
'api_host': 'https://api.datadoghq.com'}
initialize(**options)
require 'rubygems'
require 'dogapi'
dog = Dogapi::Client.new(:api_key => '<DATADOG_API_KEY>', :application_key => '<DATADOG_APPLICATION_KEY>', :endpoint => 'https://api.datadoghq.com')
curl "https://api.datadoghq.com/api/v1/validate" \
-H "DD-API-KEY: <DATADOG_API_KEY>" \
-H "DD-APPLICATION-KEY: <DATADOG_APPLICATION_KEY>"
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.
Status Codes:
200 OK201 Created202 Accepted204 No Content301 Moved Permanently304 Not Modified401 Unauthorized403 Forbidden404 Not Found409 Conflict413 Payload Too Large422 Unprocessable429 Too Many Requests500 Server ErrorExample Error Response:
{ 'errors': [
'Something bad happened to the server.',
'Your query made the server very sad.'
]
}
Example Warning Response:
{ '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.6000 per minute per organization. This can be extended on demand.Rate Limit Headers:
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.
ARGUMENTS:
check [required]:
The text for the message
host_name [required]:
The name of the host submitting the check
status [required]:
An integer for the status of the check:
tags [required]:
A list of key:val tags for this check
timestamp [optional]:
POSIX timestamp of the event.
message [optional]:
A description of why this status occurred
SIGNATURE:
POST /v1/check_run
EXAMPLE REQUEST:
from datadog import initialize, api
from datadog.api.constants import CheckStatus
options = {'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'}
initialize(**options)
check = 'app.ok'
host = 'app1'
status = CheckStatus.OK # equals 0
tags = ['env:test']
api.ServiceCheck.check(check=check, host_name=host, status=status, message='Response: 200 OK', tags=tags)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# submitting a check doesn't require an app_key
dog = Dogapi::Client.new(api_key)
dog.service_check('app.is_ok', 'app1', 0, :message => 'Response: 200 OK', :tags => ['env:test'])
api_key="<DATADOG_API_KEY>"
currenttime=$(date +%s)
curl -X POST -H "Content-type: application/json" \
-d "{
\"check\": \"app.is_ok\",
\"host_name\": \"app1\",
\"timestamp\": $currenttime,
\"status\": 0,
\"tags\": [\"env:test\"]
}" \
"https://api.datadoghq.com/api/v1/check_run?api_key=${api_key}"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
message [required]:
The comment text.
handle [optional, default = application key owner]:
The handle of the user making the comment.
related_event_id [optional, default = None]:
The id of another comment or event to reply to.
SIGNATURE:
POST /v1/comments
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Start a new discussion.
# Include a handle like this
api.Comment.create(
handle='matt@example.com',
message='Should we use COBOL or Fortran!'
)
# Or set it to None
# and the handle defaults
# to the owner of the application key
api.Comment.create(message='Should we use COBOL or Fortran?')
# Reply to a discussion.
api.Comment.create(
handle='joe@example.com',
message='Smalltalk?',
related_event_id=1234
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Make a comment.
dog.comment("I have something to say.")api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"message" : "There is a problem with the database."
}' \
"https://api.datadoghq.com/api/v1/comments"
EXAMPLE RESPONSE:
{
'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"
}
}ARGUMENTS:
message [optional, default = original message]:
The comment text.
handle [optional, default = Application key owner]:
The handle of the user making the comment.
SIGNATURE:
PUT /v1/comments/<COMMENT_ID>
from datadog import initialize, api
from time import sleep
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Edit a comment.
newcomment = api.Comment.create(
message='Should we use COBOL or Fortran or Widgets?'
)
sleep(1)
api.Comment.update(
newcomment['comment']['id'],
message='I think differently now!'
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
comment_id = "1382579089039712607"
dog = Dogapi::Client.new(api_key, app_key)
# Update a comment.
dog.update_comment(comment_id, :message => "I've changed my mind again")api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
comment_id=<COMMENT_ID>
# Create a comment to edit. Use jq (http://stedolan.github.io/jq/download/) to get the comment id.
comment_id=$(curl -X POST -H "Content-type: application/json" -H "DD-API-KEY: ${api_key}" -H "DD-APPLICATION-KEY: ${app_key}" -d '{"message" : "This comment was submitted and will be edited by the api."}' "https://api.datadoghq.com/api/v1/comments}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"message" : "Actually, I am changing my mind."
}' \
"https://api.datadoghq.com/api/v1/comments/${comment_id}"
EXAMPLE RESPONSE:
{
'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 endpoint allows you to programmatically create, update, delete, and query dashboards.
ARGUMENTS:
title [required]:
Title of the dashboard.widgets [required]:
List of widgets to display on the dashboard. Widget definitions follow this form:definition [required]:
Definition of the widget.id [optional, default=auto-generated integer]:
ID of the widget.layout [required for widgets in dashboards with free layout_type only]. The structure of the layout follows this form:x [required] The position of the widget on the x (horizontal) axis. Should be a non-negative integer.y [required] The position of the widget on the y (vertical) axis. Should be a non-negative integer.width [required] The width of the widget. Should be a non-negative integer.height [required] The height of the widget. Should be a non-negative integer.layout_type [required]:
Layout type of the dashboard. Available values are: ordered (previous timeboard) or free (previous screenboard layout)description [optional, default=None]:
Description of the dashboard.is_read_only [optional, default=False]:
Whether this dashboard is read-only. If True, only the author and admins can make changes to it.notify_list [optional, default=None]:
List of handles of users to notify when changes are made to this dashboard.template_variables [optional, default=None]:
List of template variables for this dashboard. Template variable definitions follow this form:name [required]:
The name of the variable.default [optional, default=None]:
The default value for the template variable on dashboard load.prefix [optional, default=None]:
The tag prefix associated with the variable. Only tags with this prefix appear in the variable dropdown.template_variable_presets [optional, default=None]:
Array of template variables saved views. Saved views definitions follow this form:name [required]:
The name of the saved view.template_variables [optional, default=None]:
Array of template variables that don’t have their default value. Template variable definitions follow this form:name [optional, default=None]:
The name of the variable.value [optional, default=None]:
The value of the template variable within the saved view.SIGNATURE:
POST /v1/dashboard
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
title = 'Average Memory Free Shell'
widgets = [{
'definition': {
'type': 'timeseries',
'requests': [
{'q': 'avg:system.mem.free{*}'}
],
'title': 'Average Memory Free'
}
}]
layout_type = 'ordered'
description = 'A dashboard with memory info.'
is_read_only = True
notify_list = ['user@domain.com']
template_variables = [{
'name': 'host1',
'prefix': 'host',
'default': 'my-host'
}]
saved_view = [{
'name': 'Saved views for hostname 2',
'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
]
api.Dashboard.create(title=title,
widgets=widgets,
layout_type=layout_type,
description=description,
is_read_only=is_read_only,
notify_list=notify_list,
template_variables=template_variables,
template_variable_presets=saved_views)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Create a dashboard.
title = 'Average Memory Free Shell'
widgets = [{
'definition': {
'type' => 'timeseries',
'requests' => [
{'q' => 'avg:system.mem.free{*}'}
],
'title' => 'Average Memory Free'
}
}]
layout_type = 'ordered'
description = 'A dashboard with memory info.'
is_read_only = true
notify_list = ['user@domain.com']
template_variables = [{
'name' => 'host',
'prefix' => 'host',
'default' => '<HOSTNAME_1>'
}]
saved_view = [{
'name': 'Saved views for hostname 2',
'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
]
dog.create_board(title, widgets, layout_type, {
'description' => description,
'is_read_only' => is_read_only,
'notify_list' => notify_list,
'template_variables' => template_variables,
'template_variable_presets' => saved_view
})
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"title": "Average Memory Free Shell",
"widgets": [
{
"definition": {
"type": "timeseries",
"requests": [{"q": "avg:system.mem.free{*}"}],
"title": "Average Memory Free"
}
}
],
"layout_type": "ordered",
"description": "A dashboard with memory info.",
"is_read_only": true,
"notify_list": ["user@domain.com"],
"template_variables": [
{"name": "host", "prefix": "host", "default": "<HOSTNAME_1>"}
],
"template_variable_presets": [
{
"name": "Saved views for hostname 2",
"template_variables": [
{"name": "host", "value": "<HOSTNAME_2>"}
]
}
]
}' \
"https://api.datadoghq.com/api/v1/dashboard"
EXAMPLE RESPONSE:
{
'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"
}
ARGUMENTS:
title [required]:
Title of the dashboard.widgets [required]:
List of widgets to display on the dashboard. Widget definitions follow this form:definition [required]:
Definition of the widget.id [optional, default=auto-generated integer]:
ID of the widget.layout [required for widgets in dashboards with free layout_type only]. The structure of the layout follows this form:x [required] The position of the widget on the x (horizontal) axis. Should be a non-negative integer.y [required] The position of the widget on the y (vertical) axis. Should be a non-negative integer.width [required] The width of the widget. Should be a non-negative integer.height [required] The height of the widget. Should be a non-negative integer.layout_type [required]:
Layout type of the dashboard. Available values are: ordered (previous timeboard) or free (previous screenboard layout)description [optional, default=None]:
Description of the dashboard.is_read_only [optional, default=False]:
Whether this dashboard is read-only. If True, only the author and admins can make changes to it.notify_list [optional, default=None]:
List of handles of users to notify when changes are made to this dashboard.template_variables [optional, default=None]:
List of template variables for this dashboard. Template variable definitions follow this form:name [required]:
The name of the variable.default [optional, default=None]:
The default value for the template variable on dashboard load.prefix [optional, default=None]:
The tag prefix associated with the variable. Only tags with this prefix appear in the variable dropdown.template_variable_presets [optional, default=None]:
Array of template variables saved views. Saved views definitions follow this form:name [required]:
The name of the saved view.template_variables [optional, default=None]:
Array of template variables that don’t have their default value. Template variable definitions follow this form:name [optional, default=None]:
The name of the variable.value [optional, default=None]:
The value of the template variable within the saved view.SIGNATURE:
PUT /v1/dashboard/<DASHBOARD_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'}
initialize(**options)
dashboard_id = '<DASHBOARD_ID>'
title = 'Sum of Memory Free'
widgets = [{
'definition': {
'type': 'timeseries',
'requests': [
{'q': 'sum:system.mem.free{*}'}
],
'title': 'Sum Memory Free Shell'
}
}]
layout_type = 'ordered'
description = 'An updated dashboard with memory info.'
is_read_only = True
notify_list = ['user@domain.com']
template_variables = [{
'name': 'host1',
'prefix': 'host',
'default': 'my-host'
}]
saved_view = [{
'name': 'Saved views for hostname 2',
'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
]
api.Dashboard.update(dashboard_id,
title=title,
widgets=widgets,
layout_type=layout_type,
description=description,
is_read_only=is_read_only,
notify_list=notify_list,
template_variables=template_variables,
template_variable_presets=saved_view)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dashboard_id = '<DASHBOARD_ID>'
title = 'Sum of Memory Free'
widgets = [{
'definition': {
'type' => 'timeseries',
'requests' => [
{'q' => 'sum:system.mem.free{*}'}
],
'title' => 'Sum Memory Free Shell'
}
}]
layout_type = 'ordered'
description = 'An updated dashboard with memory info.'
is_read_only = true
notify_list = ['user@domain.com']
template_variables = [{
'name' => 'host1',
'prefix' => 'host',
'default' => 'my-host'
}]
saved_view = [{
'name': 'Saved views for hostname 2',
'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
]
dog.update_board(dashboard_id, title, widgets, layout_type, {
'description' => description,
'is_read_only' => is_read_only,
'notify_list' => notify_list,
'template_variables' => template_variables,
'template_variable_presets' => saved_view
})
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
dashboard_id="<DASHBOARD_ID>"
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"title": "Sum of Memory Free",
"widgets": [
{
"definition": {
"type": "timeseries",
"requests": [{"q": "sum:system.mem.free{*}"}],
"title": "Sum Memory Free Shell"
}
}
],
"layout_type": "ordered",
"description": "An updated dashboard with memory info.",
"is_read_only": true,
"notify_list": ["user@domain.com"],
"template_variables": [
{"name": "host", "prefix": "host", "default": "<HOSTNAME_1>"}
],
"template_variable_presets": [
{
"name": "Saved views for hostname 2",
"template_variables": [{"name": "host", "value": "<HOSTNAME_2>"}]
}
]
}' \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/dashboard/<DASHBOARD_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
dashboard_id = '<DASHBOARD_ID>'
api.Dashboard.delete(dashboard_id)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dashboard_id = '<DASHBOARD_ID>'
dog.delete_board(dashboard_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
dashboard_id="<DASHBOARD_ID>"
curl -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/dashboard/<DASHBOARD_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
dashboard_id = '<DASHBOARD_ID>'
api.Dashboard.get(dashboard_id)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dashboard_id = '<DASHBOARD_ID>'
dog.get_board(dashboard_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
dashboard_id="<DASHBOARD_ID>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}"
EXAMPLE RESPONSE:
{
'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"
}
Fetch all dashboards.
ARGUMENTS:
This end point takes no JSON arguments.
SIGNATURE:
GET /v1/dashboard
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.Dashboard.get_all()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.get_all_boards()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard"
EXAMPLE RESPONSE:
{
'dashboards': [{
'created_at': '2019-02-28T17:12:59.327729+00:00',
'is_read_only': False,
'description': 'My Screenboard Description',
'title': 'My Screenboard',
'url': '/dashboard/grh-zkj-h2c/my-screenboard',
'layout_type': 'free',
'modified_at': '2019-03-13T19:09:40.930616+00:00',
'author_handle':'user@domain.com',
'id': 'grh-zkj-h2c'
},
{
'created_at': '2019-02-28T17:45:11.535045+00:00',
'is_read_only': False,
'description': 'My Timeboard Description',
'title': 'My Timeboard',
'url': '/dashboard/4qf-77b-uhc/my-timeboard',
'layout_type': 'ordered',
'modified_at': '2019-03-11T14:22:03.131495+00:00',
'author_handle':'user@domain.com',
'id': '4qf-77b-uhc'
}
]
}
{
"dashboards": [{
"created_at" => "2019-02-28T17:12:59.327729+00:00",
"is_read_only" => false,
"description" => "My Screenboard Description",
"title" => "My Screenboard",
"url" => "/dashboard/grh-zkj-h2c/my-screenboard",
"layout_type" => "free",
"modified_at" => "2019-03-13T19:09:40.930616+00:00",
"author_handle": "user@domain.com",
"id" => "grh-zkj-h2c"
}, {
"created_at" => "2019-02-28T17:45:11.535045+00:00",
"is_read_only" => false,
"description" => "My Timeboard Description",
"title" => "My Timeboard",
"url" => "/dashboard/4qf-77b-uhc/my-timeboard",
"layout_type" => "ordered",
"modified_at" => "2019-03-11T14:22:03.131495+00:00",
"author_handle": "user@domain.com",
"id" => "4qf-77b-uhc"
}]
}
{
"dashboards": [{
"created_at": "2019-02-28T17:12:59.327729+00:00",
"is_read_only": false,
"description": "My Screenboard Description",
"title": "My Screenboard",
"url": "/dashboard/grh-zkj-h2c/my-screenboard",
"layout_type": "free",
"modified_at": "2019-03-13T19:09:40.930616+00:00",
"author_handle": "user@domain.com",
"id": "grh-zkj-h2c"
},
{
"created_at": "2019-02-28T17:45:11.535045+00:00",
"is_read_only": false,
"description": "My Timeboard Description",
"title": "My Timeboard",
"url": "/dashboard/4qf-77b-uhc/my-timeboard",
"layout_type": "ordered",
"modified_at": "2019-03-11T14:22:03.131495+00:00",
"author_handle": "user@domain.com",
"id": "4qf-77b-uhc"
}
]
}
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.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/dashboard/lists/manual/<LIST_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.DashboardList.get(4741)require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.get_dashboard_list(4741)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/dashboard/lists/manual
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.DashboardList.get_all()require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.get_all_dashboard_lists()api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
name [required]:
The name of the dashboard list.SIGNATURE:
POST /v1/dashboard/lists/manual
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
name = 'My Dashboard List'
api.DashboardList.create(name=name)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
name = 'My Dashboard List'
result = dog.create_dashboard_list(name)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name": "My Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual"
EXAMPLE RESPONSE:
{
'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
ARGUMENTS:
name [required]:
The name of the dashboard list.SIGNATURE:
PUT /v1/dashboard/lists/manual/<LIST_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
list_id = 4741
name = 'My Updated Dashboard List'
api.DashboardList.update(list_id, name=name)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
name = 'My Updated Dashboard List'
result = dog.update_dashboard_list(list_id, name)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name": "My Updated Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/dashboard/lists/manual/<LIST_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.DashboardList.delete(4741)require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.delete_dashboard_list(4741)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}"
EXAMPLE RESPONSE:
{
'deleted_dashboard_list_id': 4741
}[
"200",
{
"deleted_dashboard_list_id" => 4741
}
]{
"deleted_dashboard_list_id": 4741
}Fetch the dashboard list’s dashboard definitions.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v2/dashboard/lists/manual/<LIST_ID>/dashboards
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.DashboardList.v2.get_items(4741)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.v2.get_items_of_dashboard_list(4741)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"
EXAMPLE RESPONSE:
{
'total': 5,
'dashboards': [
{
'popularity': 0,
'is_shared': False,
'author': {
'handle': None,
'name': None
},
'url': '/screen/integration/87/aws-dynamodb',
'title': 'AWS DynamoDB',
'modified': None,
'created': None,
'is_favorite': True,
'is_read_only': True,
'type': 'integration_screenboard',
'id': '87',
'icon': '/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png'
},
{
'popularity': 0,
'is_shared': False,
'author': {
'handle': None,
'name': None
},
'url': '/dash/integration/23/postgres---metrics',
'title': 'Postgres - Metrics',
'modified': None,
'created': None,
'is_favorite': True,
'is_read_only': True,
'type': 'integration_timeboard',
'id': '23',
'icon': '/static/v/34.254868/images/saas_logos/small/postgres.png'
},
{
'popularity': 0,
'is_shared': False,
'author': {
'handle': 'test1@datadoghq.com',
'name': 'Author Name'
},
'url': '/dashboard/qts-q2k-yq6/trace-api',
'title': 'Trace API',
'modified': '2018-03-16T13:39:39.517133+00:00',
'created': '2015-10-21T13:22:48.633391+00:00',
'is_favorite': False,
'is_read_only': False,
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6',
'icon': None
},
{
'popularity': 0,
'is_shared': False,
'author': {
'handle': 'test2@datadoghq.com',
'name': 'Other Author Name'
},
'url': '/dashboard/rys-xwq-geh/agent-stats',
'title': 'Agent Stats',
'modified': '2018-03-16T12:54:25.968134+00:00',
'created': '2014-06-18T18:19:00.974763+00:00',
'is_favorite': False,
'is_read_only': False,
'type': 'custom_screenboard',
'id': 'rys-xwq-geh',
'icon': None
},
{
'popularity': 0,
'is_shared': False,
'author': {
'handle': None,
'name': None
},
'url': '/dash/host/3245468',
'title': 'agent-gui',
'modified': None,
'created': None,
'is_favorite': False,
'is_read_only': True,
'type': 'host_timeboard',
'id': '3245468',
'icon': None
}
]
}
[
"200",
{
"total" => 5,
"dashboards" => [
{
"popularity" => 0,
"title" => "AWS DynamoDB",
"is_favorite" => true,
"id" => "87",
"icon" => "/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png",
"is_shared" => false,
"author" => {
"handle" => nil,
"name" => nil
},
"url" => "/screen/integration/87/aws-dynamodb",
"created" => nil,
"modified" => nil,
"is_read_only" => true,
"type" => "integration_screenboard"
},
{
"popularity" => 0,
"title" => "Postgres - Metrics",
"is_favorite" => true,
"id" => "23",
"icon" => "/static/v/34.254868/images/saas_logos/small/postgres.png",
"is_shared" => false,
"author" => {
"handle" => nil,
"name" => nil
},
"url" => "/dash/integration/23/postgres---metrics",
"created" => nil,
"modified" => nil,
"is_read_only" => true,
"type" => "integration_timeboard"
},
{
"popularity" => 0,
"title" => "Trace API",
"is_favorite" => false,
"id" => "qts-q2k-yq6",
"icon" => nil,
"is_shared" => false,
"author" => {
"handle" => "test1@datadoghq.com",
"name" => "Author Name"
},
"url" => "/dashboard/qts-q2k-yq6/trace-api",
"created" => "2015-10-21T13:22:48.633391+00:00",
"modified" => "2018-03-16T13:39:39.517133+00:00",
"is_read_only" => false,
"type" => "custom_timeboard"
},
{
"popularity" => 0,
"title" => "Agent Stats",
"is_favorite" => false,
"id" => "rys-xwq-geh",
"icon" => nil,
"is_shared" => false,
"author" => {
"handle" => "test2@datadoghq.com",
"name" => "Other Author Name"
},
"url" => "/dashboard/rys-xwq-geh/agent-stats",
"created" => "2014-06-18T18:19:00.974763+00:00",
"modified" => "2018-03-16T12:54:25.968134+00:00",
"is_read_only" => false,
"type" => "custom_screenboard"
},
{
"popularity" => 0,
"title" => "agent-gui",
"is_favorite" => false,
"id" => "3245468",
"icon" => nil,
"is_shared" => false,
"author" => {
"handle" => nil,
"name" => nil
},
"url" => "/dash/host/3245468",
"created" => nil,
"modified" => nil,
"is_read_only" => true,
"type" => "host_timeboard"
}
]
}
]
{
"total": 5,
"dashboards": [
{
"popularity": 0,
"is_shared": False,
"author": {
"handle": None,
"name": None
},
"url": "/screen/integration/87/aws-dynamodb",
"title": "AWS DynamoDB",
"modified": None,
"created": None,
"is_favorite": True,
"is_read_only": True,
"type": "integration_screenboard",
"id": "87",
"icon": "/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png"
},
{
"popularity": 0,
"is_shared": False,
"author": {
"handle": None,
"name": None
},
"url": "/dash/integration/23/postgres---metrics",
"title": "Postgres - Metrics",
"modified": None,
"created": None,
"is_favorite": True,
"is_read_only": True,
"type": "integration_timeboard",
"id": "23",
"icon": "/static/v/34.254868/images/saas_logos/small/postgres.png"
},
{
"popularity": 0,
"is_shared": False,
"author": {
"handle": "test1@datadoghq.com",
"name": "Author Name"
},
"url": "/dashboard/qts-q2k-yq6/trace-api",
"title": "Trace API",
"modified": "2018-03-16T13:39:39.517133+00:00",
"created": "2015-10-21T13:22:48.633391+00:00",
"is_favorite": False,
"is_read_only": False,
"type": "custom_timeboard",
"id": "qts-q2k-yq6",
"icon": None
},
{
"popularity": 0,
"is_shared": False,
"author": {
"handle": "test2@datadoghq.com",
"name": "Other Author Name"
},
"url": "/dashboard/rys-xwq-geh/agent-stats",
"title": "Agent Stats",
"modified": "2018-03-16T12:54:25.968134+00:00",
"created": "2014-06-18T18:19:00.974763+00:00",
"is_favorite": False,
"is_read_only": False,
"type": "custom_screenboard",
"id": "rys-xwq-geh",
"icon": None
},
{
"popularity": 0,
"is_shared": False,
"author": {
"handle": None,
"name": None
},
"url": "/dash/host/3245468",
"title": "agent-gui",
"modified": None,
"created": None,
"is_favorite": False,
"is_read_only": True,
"type": "host_timeboard",
"id": "3245468",
"icon": None
}
]
}
Add dashboards to an existing dashboard list.
ARGUMENTS:
dashboards [required]:
A list of dashboards to add to the list.
Dashboard definitions follow this form:
type [required]:
The type of the dashboard.
The type must be one of:
"custom_timeboard""custom_screenboard""integration_screenboard""integration_timeboard""host_timeboard"id [required]:
The id of the dashboard.
SIGNATURE:
POST /v2/dashboard/lists/manual/<LIST_ID>/dashboards
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
list_id = 4741
dashboards = [
{
'type': 'custom_screenboard',
'id': 'rys-xwq-geh'
},
{
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6'
},
{
'type': 'integration_screenboard',
'id': '87'
},
{
'type': 'integration_timeboard',
'id': '23'
},
{
'type': 'host_timeboard',
'id': '3245468'
}
]
api.DashboardList.v2.add_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
dashboards = [
{
"type" => "custom_screenboard",
"id" => "rys-xwq-geh"
},
{
"type" => "custom_timeboard",
"id" => "qts-q2k-yq6"
},
{
"type" => "integration_screenboard",
"id" => "87"
},
{
"type" => "integration_timeboard",
"id" => "23"
},
{
"type" => "host_timeboard",
"id" => "3245468"
}
]
result = dog.v2.add_items_to_dashboard_list(list_id, dashboards)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"dashboards": [
{
"type": "custom_screenboard",
"id": "rys-xwq-geh"
},
{
"type": "custom_timeboard",
"id": "qts-q2k-yq6"
},
{
"type": "integration_screenboard",
"id": "87"
},
{
"type": "integration_timeboard",
"id": "23"
},
{
"type": "host_timeboard",
"id": "3245468"
}
]
}' \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"
EXAMPLE RESPONSE:
{
'added_dashboards_to_list': [
{
'type': 'custom_screenboard',
'id': 'rys-xwq-geh'
},
{
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6'
},
{
'type': 'integration_screenboard',
'id': '87'
},
{
'type': 'integration_timeboard',
'id': '23'
},
{
'type': 'host_timeboard',
'id': '3245468'
}
]
}
[
"200",
{
"added_dashboards_to_list" => [
{
"type" => "custom_screenboard",
"id" => "rys-xwq-geh"
},
{
"type" => "custom_timeboard",
"id" => "qts-q2k-yq6"
},
{
"type" => "integration_screenboard",
"id" => "87"
},
{
"type" => "integration_timeboard",
"id" => "23"
},
{
"type" => "host_timeboard",
"id" => "3245468"
}
]
}
]
{
"added_dashboards_to_list": [
{
"type": "custom_screenboard",
"id": "rys-xwq-geh"
},
{
"type": "custom_timeboard",
"id": "qts-q2k-yq6"
},
{
"type": "integration_screenboard",
"id": "87"
},
{
"type": "integration_timeboard",
"id": "23"
},
{
"type": "host_timeboard",
"id": "3245468"
}
]
}
Update dashboards of an existing dashboard list.
ARGUMENTS:
dashboards [required]:
The new list of dashboards for the dashboard list.
Dashboard definitions follow this form:
type [required]:
The type of the dashboard.
The type must be one of:
"custom_timeboard""custom_screenboard""integration_screenboard""integration_timeboard""host_timeboard"id [required]:
The id of the dashboard.
SIGNATURE:
PUT /v2/dashboard/lists/manual/<LIST_ID>/dashboards
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
list_id = 4741
dashboards = [
{
'type': 'custom_screenboard',
'id': 'rys-xwq-geh'
},
{
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6'
},
{
'type': 'integration_screenboard',
'id': '87'
},
{
'type': 'integration_timeboard',
'id': '23'
},
{
'type': 'host_timeboard',
'id': '3245468'
}
]
api.DashboardList.v2.update_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
dashboards = [
{
"type" => "custom_screenboard",
"id" => "rys-xwq-geh"
},
{
"type" => "custom_timeboard",
"id" => "qts-q2k-yq6"
},
{
"type" => "integration_screenboard",
"id" => "87"
},
{
"type" => "integration_timeboard",
"id" => "23"
},
{
"type" => "host_timeboard",
"id" => "3245468"
}
]
result = dog.v2.update_items_of_dashboard_list(list_id, dashboards)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"dashboards": [
{
"type": "custom_screenboard",
"id": "rys-xwq-geh"
},
{
"type": "custom_timeboard",
"id": "qts-q2k-yq6"
},
{
"type": "integration_screenboard",
"id": "87"
},
{
"type": "integration_timeboard",
"id": "23"
},
{
"type": "host_timeboard",
"id": "3245468"
}
]
}' \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"
EXAMPLE RESPONSE:
{
'dashboards': [
{
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6'
},
{
'type': 'custom_screenboard',
'id': 'rys-xwq-geh'
},
{
'type': 'integration_timeboard',
'id': '23'
},
{
'type': 'integration_screenboard',
'id': '87'
},
{
'type': 'host_timeboard',
'id': '3245468'
}
]
}
[
"200",
{
"dashboards" => [
{
"type" => "custom_timeboard",
"id" => "qts-q2k-yq6"
},
{
"type" => "custom_screenboard",
"id" => "rys-xwq-geh"
},
{
"type" => "integration_timeboard",
"id" => "23"
},
{
"type" => "integration_screenboard",
"id" => "87"
},
{
"type" => "host_timeboard",
"id" => "3245468"
}
]
}
]
{
"dashboards": [
{
"type": "custom_timeboard",
"id": "qts-q2k-yq6"
},
{
"type": "custom_screenboard",
"id": "rys-xwq-geh"
},
{
"type": "integration_timeboard",
"id": "23"
},
{
"type": "integration_screenboard",
"id": "87"
},
{
"type": "host_timeboard",
"id": "3245468"
}
]
}
Delete dashboards from an existing dashboard list.
ARGUMENTS:
dashboards [required]:
A list of dashboards to remove from the list.
Dashboard definitions follow this form:
type [required]:
The type of the dashboard.
The type must be one of:
"custom_timeboard""custom_screenboard""integration_screenboard""integration_timeboard""host_timeboard"id [required]:
The id of the dashboard.
SIGNATURE:
DELETE /v2/dashboard/lists/manual/<LIST_ID>/dashboards
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
list_id = 4741
dashboards = [
{
'type': 'custom_screenboard',
'id': 'rys-xwq-geh'
},
{
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6'
},
{
'type': 'integration_screenboard',
'id': '87'
},
{
'type': 'integration_timeboard',
'id': '23'
},
{
'type': 'host_timeboard',
'id': '3245468'
}
]
api.DashboardList.v2.delete_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
dashboards = [
{
"type" => "custom_screenboard",
"id" => "rys-xwq-geh"
},
{
"type" => "custom_timeboard",
"id" => "qts-q2k-yq6"
},
{
"type" => "integration_screenboard",
"id" => "87"
},
{
"type" => "integration_timeboard",
"id" => "23"
},
{
"type" => "host_timeboard",
"id" => "3245468"
}
]
result = dog.v2.delete_items_from_dashboard_list(list_id, dashboards)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
list_id=4741
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"dashboards": [
{
"type": "custom_screenboard",
"id": "rys-xwq-geh"
},
{
"type": "custom_timeboard",
"id": "qts-q2k-yq6"
},
{
"type": "integration_screenboard",
"id": "87"
},
{
"type": "integration_timeboard",
"id": "23"
},
{
"type": "host_timeboard",
"id": "3245468"
}
]
}' \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"
EXAMPLE RESPONSE:
{
'deleted_dashboards_from_list': [
{
'type': 'custom_screenboard',
'id': 'rys-xwq-geh'
},
{
'type': 'custom_timeboard',
'id': 'qts-q2k-yq6'
},
{
'type': 'integration_screenboard',
'id': '87'
},
{
'type': 'integration_timeboard',
'id': '23'
},
{
'type': 'host_timeboard',
'id': '3245468'
}
]
}
[
"200",
{
"deleted_dashboards_from_list" => [
{
"type" => "custom_screenboard",
"id" => "rys-xwq-geh"
},
{
"type" => "custom_timeboard",
"id" => "qts-q2k-yq6"
},
{
"type" => "integration_screenboard",
"id" => "87"
},
{
"type" => "integration_timeboard",
"id" => "23"
},
{
"type" => "host_timeboard",
"id" => "3245468"
}
]
}
]
{
"deleted_dashboards_from_list": [
{
"type": "custom_screenboard",
"id": "rys-xwq-geh"
},
{
"type": "custom_timeboard",
"id": "qts-q2k-yq6"
},
{
"type": "integration_screenboard",
"id": "87"
},
{
"type": "integration_timeboard",
"id": "23"
},
{
"type": "host_timeboard",
"id": "3245468"
}
]
}
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.
ARGUMENTS:
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.rrule standard for defining recurring events. For example to have a recurring event on the first day of each month, select a type of rrule and set the FREQ to MONTHLY and BYMONTHDAY to 1. Most common RRULE options from the iCalendar Spec are supported.
Note: Attributes specifying the duration in RRULE are not supported, e.g. DTSTART, DTEND, DURATION.
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 exclusive
until_date (optional) the date at which the recurrence should end as a POSIX timestmap. until_occurences and until_date are mutually exclusive
SIGNATURE:
POST /v1/downtime
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Repeat for 3 hours (starting now) on every week day for 4 weeks.
start_ts = int(time.time())
end_ts = start_ts + (3 * 60 * 60)
end_reccurrence_ts = start_ts + (4 * 7 * 24 * 60 * 60) # 4 weeks from now
recurrence = {
'type': 'weeks',
'period': 1,
'week_days': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
'until_date': end_reccurrence_ts
}
# Schedule downtime
api.Downtime.create(
scope='env:staging',
start=start_ts,
end=end_ts,
recurrence=recurrence
)
# OR use RRULE reccurence
rrule_recurrence = {
'type': 'rrule',
'rrule': 'FREQ=MONTHLY;BYSETPOS=3;BYDAY=WE;INTERVAL=1',
}
# Schedule downtime
api.Downtime.create(
scope='env:staging',
start=start_ts,
end=end_ts,
recurrence=rrule_recurrence
)
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Repeat for 3 hours (starting now) on every week day for 4 weeks.
start_ts = Time.now.to_i
end_ts = start_ts + (3 * 60 * 60)
end_reccurrence_ts = start_ts + (4 * 7 * 24 * 60 * 60) # 4 weeks from now
recurrence = {
'type' => 'weeks',
'period' => 1,
'week_days' => %w[Mon Tue Wed Thu Fri],
'until_date' => end_reccurrence_ts
}
# Schedule downtime
dog.Downtime.create(
'env:staging',
start: start_ts,
end: end_ts,
recurrence: recurrence
)
# OR use RRULE reccurence
rrule_recurrence = {
'type' => 'rrule',
'rrule' => 'FREQ=MONTHLY;BYSETPOS=3;BYDAY=WE;INTERVAL=1',
}
# Schedule downtime
dog.Downtime.create(
'env:staging',
start: start_ts,
end: end_ts,
recurrence: rrule_recurrence
)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
start=$(date +%s)
end=$(date -v+3H +%s)
end_recurrence=$(date -v+21d +%s)
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"scope": "env:prod",
"start": '"${start}"',
"end": '"${end}"',
"recurrence": {
"type": "weeks",
"period": 1,
"week_days": ["Mon", "Tue", "Wed", "Thu", "Fri"],
"until_date": '"${end_recurrence}"'
}
}' \
"https://api.datadoghq.com/api/v1/downtime"
# OR use RRULE reccurence
-d '{
"scope": "env:prod",
"start": '"${start}"',
"end": '"${end}"',
"recurrence": {
"type": "rrule",
"rrule": "FREQ=MONTHLY;BYSETPOS=3;BYDAY=WE;INTERVAL=1"
}
}' \
"https://api.datadoghq.com/api/v1/downtime"
EXAMPLE RESPONSE:
{
'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
}
# with RRULE recurrence
{
...
'recurrence': {
'type': 'rrule',
'rrule': 'FREQ=MONTHLY;BYSETPOS=3;BYDAY=WE;INTERVAL=1'
}
[
'200', {
'disabled' => false,
'canceled' => nil,
'active' => true,
'message' => nil,
'id' => 169_267_581,
'end' => 1_445_978_819,
'parent_id' => nil,
'monitor_id' => nil,
'monitor_tags' => ['*'],
'recurrence' => {
'until_date' => 1_448_387_219,
'until_occurrences' => nil,
'week_days' => %w[Mon Tue Wed Thu Fri],
'type' => 'weeks',
'period' => 1
},
'start' => 1_445_968_019,
'creator_id' => 3658,
'scope' => ['env:testing'],
'updater_id' => nil
}
]
# with RRULE recurrence
{
...
'recurrence' => {
'type' => 'rrule',
'rrule' => FREQ=MONTHLY;BYSETPOS=3;BYDAY=WE;INTERVAL=1
}
{
"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
}
# with RRULE recurrence
{
...
"recurrence": {
"type": "rrule",
"rrule": "FREQ=MONTHLY;BYSETPOS=3;BYDAY=WE;INTERVAL=1"
}
ARGUMENTS:
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.rrule standard for defining recurring events. For example to have a recurring event on the first day of each month, select a type of rrule and set the FREQ to MONTHLY and BYMONTHDAY to 1. Most common RRULE options from the iCalendar Spec are supported.
Note: Attributes specifying the duration in RRULE are not supported, e.g. DTSTART, DTEND, DURATION.
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 exclusive
until_date (optional) the date at which the recurrence should end as a POSIX timestmap. until_occurences and until_date are mutually exclusive
SIGNATURE:
PUT /v1/downtime/<DOWNTIME_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Get an existing downtime
stagingDowntimes = []
downtimes = api.Downtime.get_all()
for item in downtimes:
if item['scope'] == ['env:staging']:
stagingDowntimes.append(item)
# Update that downtime
api.Downtime.update(
stagingDowntimes[0]['id'],
scope='env:staging',
end=int(time.time()) + 60000,
message="Doing some testing on staging."
)
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Update a downtime
downtime_id = 4336
dog.update_downtime(
downtime_id,
scope: 'env:testing',
end: Time.now.to_i + 60_000,
message: 'Doing some testing on staging.'
)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
downtime_id=4336
# Create a downtime to update
currenttime=$(date +%s)
downtime_id=$(curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "{
\"scope\": \"env:prod\",
\"start\": \"${currenttime}\"
}" \
"https://api.datadoghq.com/api/v1/downtime}" | jq '.id')
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"scope": "env:staging",
"message": "Doing some testing on staging"
}' \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}"
EXAMPLE RESPONSE:
{
'active': True,
'disabled': False,
'end': 1420447087,
'id': 2910,
'message': 'Doing some testing on staging.',
'monitor_tags': ['*'],
'scope': ['env:staging'],
'start': 1420387032
}
[
'200', {
'end' => 1_418_303_372,
'disabled' => false,
'start' => 1_418_224_729,
'active' => true,
"monitor_tags": ['*'],
'scope' => ['env:testing'],
'message' => 'Doing some testing on staging.',
'id' => 4336
}
]
{
"active": true,
"disabled": false,
"end": 1418303372,
"id": 4336,
"message": "Doing some testing on staging",
"monitor_tags": ["*"],
"scope": [
"env:staging"
],
"start": 1418224729
}
ARGUMENTS:
id [required]:
The integer ID of the downtime to be canceledSIGNATURE:
DELETE /v1/downtime/<DOWNTIME_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Cancel downtime
api.Downtime.delete(1654)
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.cancel_downtime(1655)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
downtime_id=1656
# Create a downtime to delete
currenttime=$(date +%s)
downtime_id=$(curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "{
\"scope\": \"env:prod\",
\"start\": \"${currenttime}\"
}" \
"https://api.datadoghq.com/api/v1/downtime" | jq '.id')
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}"
EXAMPLE RESPONSE:
This endpoint does not return JSON on successful requests.
This endpoint is not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.
ARGUMENTS:
scope [required]:
Cancel all downtimes with the given scope(s), e.g.:
SIGNATURE:
POST /v1/downtime/cancel/by_scope
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Cancel all downtimes with scope
api.Downtime.cancel_downtime_by_scope('env:testing')
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Cancel all downtimes with the given scope
dog.cancel_downtime_by_scope('env:testing')
#!/bin/bash
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "Accept: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "{
\"scope\": \"host:i-123\"
}" \
"https://api.datadoghq.com/api/v1/downtime/cancel/by_scope"
EXAMPLE RESPONSE:
{"cancelled_ids": [123456789, 123456790]}
['200', { 'cancelled_ids' => [123_456_789, 123_456_790] }]
{
"cancelled_ids":[123456789,123456790]
}ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/downtime/<DOWNTIME_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Get a downtime
api.Downtime.get(2910)
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get a downtime object
downtime_id = 1625
dog.get_downtime(downtime_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
downtime_id=2473
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}"
EXAMPLE RESPONSE:
{'active': True,
'disabled': False,
'end': 1420447087,
'id': 2910,
'message': 'Doing some testing on staging.',
'monitor_tags': ['*'],
'scope': ['env:staging'],
'start': 1420387032
}
{
'end' => 1_412_793_983,
'disabled' => true,
'start' => 1_412_792_983,
'active' => false,
'monitor_tags' => ['*'],
'scope' => ['env:staging'],
'id' => 1625
}
{
"active": True,
"disabled": False,
"end": 1420447087,
"id": 2910,
"message": "Doing some testing on staging.",
"monitor_tags": ["*"],
"scope": ["env:staging"],
"start": 1420387032
}
ARGUMENTS:
current_only [optional, default = False]:
Only return downtimes that are active when the request is made.SIGNATURE:
GET /v1/downtime
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Get all downtimes
print(api.Downtime.get_all())
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get all downtimes
dog.get_all_downtimes
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/downtime"
EXAMPLE RESPONSE:
[
{
'active': False,
'disabled': True,
'end': 1412793983,
'id': 1625,
'monitor_tags': ['*'],
'scope': ['env:staging'],
'start': 1412792983
},
{
'active': False,
'disabled': True,
'end': None,
'id': 1626,
'monitor_tags': ['*'],
'scope': ['*'],
'start': 1412792985
}
]
[
'200', [{
'end' => 1_412_793_983,
'disabled' => true,
'start' => 1_412_792_983,
'active' => false,
'monitor_tags' => ['*'],
'scope' => ['env:staging'],
'id' => 1625
}, {
'end' => nil,
'disabled' => true,
'start' => 1_412_792_985,
'active' => false,
'monitor_tags' => ['*'],
'scope' => ['*'],
'id' => 1626
}]
]
[
{
"active": false,
"disabled": true,
"end": 1412793983,
"id": 1625,
"monitor_tags": ["*"],
"scope": [
"env:staging"
],
"start": 1412792983
},
{
"active": false,
"disabled": true,
"end": null,
"id": 1626,
"monitor_tags": ["*"],
"scope": [
"*"
],
"start": 1412792985
}
]
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/
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/graph/embed
EXAMPLE REQUEST:
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Call Embed API function
api.Embed.get_all()
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get all with API Call
dog.get_all_embeds()api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed"
EXAMPLE RESPONSE:
{
"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.
ARGUMENTS:
graph_json [required]:
The graph definition in JSON. Same format that is available on the JSON tab of the graph editortimeframe [optional, default=1_hour]:
The timegrame for the graph. Must be one of:size [optional, default=medium]:
The size of the graph. Must be one:legend [optional, default=no]:
The flag determining if the graph includes a legend. Must be one of yes or no.title [optional, default=Embed created through API]:
Determines graph title.
Must be at least 1 character.SIGNATURE:
POST /v1/graph/embed
EXAMPLE REQUEST:
from datadog import initialize, api
import json
# Intialize request parameters including API/APP key
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Create an embed graph definition as a dict and format as JSON
graph_json = {
"requests": [{
"q": "avg:system.load.1{*}"
}],
"viz": "timeseries",
"events": []
}
graph_json = json.dumps(graph_json)
api.Embed.create(
graph_json=graph_json,
timeframe="1_hour",
size="medium",
legend="no"
)
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Prepare parameters
graph_json = '{
"requests": [{
"q": "avg:system.load.1{*}"
}],
"viz": "timeseries",
"events": []
}
'
timeframe = "1_hour"
size = "medium"
legend = "no"
title = "Embed created through API"
# Create parameter hash
description = {:timeframe => timeframe, :size => size, :legend => legend, :title => title
}
# Make API Call
status, result = dog.create_embed(graph_json, description)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d 'graph_json={"requests":[{"q":"avg:system.load.1{*}"}],"viz":"timeseries","events":[]}' \
-d "timeframe=1_hour" \
-d "size=medium" \
-d "legend=yes" \
"https://api.datadoghq.com/api/v1/graph/embed"
EXAMPLE RESPONSE:
{
"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]}.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/graph/embed/<EMBED_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Call Embed API function
api.Embed.get(embed_id, legend="no", size="medium", timeframe="1_hour")
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Get embed with API Call
dog.enable_embed(embed_id)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed/${embed_id}"
EXAMPLE RESPONSE:
{
"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]}.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/graph/embed/<EMBED_ID>/enable
EXAMPLE REQUEST:
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Call Embed API function
api.Embed.enable(embed_id)
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Enable with API Call
dog.enable_embed(embed_id)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/enable"
EXAMPLE RESPONSE:
{
"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]}.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/graph/embed/<EMBED_ID>/revoke
EXAMPLE REQUEST:
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Call Embed API function
api.Embed.revoke(embed_id)
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Revoke with API Call
dog.revoke_embed(embed_id)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/revoke"
EXAMPLE RESPONSE:
{
"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 endpoint allows you to post events to the stream. Tag them, set priority and event aggregate them with other events.
ARGUMENTS:
title [required]:
The event title. Limited to 100 characters.
Use msg_title with the Datadog Ruby library.text [required]:
The body of the event. Limited to 4000 characters.
The text supports markdown.
Use msg_text with the Datadog Ruby librarydate_happened [optional, default = now]:
POSIX timestamp of the event. Must be sent as an integer (i.e. no quotes). Limited to events no older than 1 year, 24 days (389 days)priority [optional, default = normal]:
The priority of the event: normal or low.host [optional, default=None]:
Host name to associate with the event. Any tags associated with the host are also applied to this event.tags [optional, default=None]:
A list of tags to apply to the event.alert_type [optional, default = info]:
If it’s an alert event, set its type between: error, warning, info, and success.aggregation_key [optional, default=None]:
An arbitrary string to use for aggregation. Limited to 100 characters.
If you specify a key, all events using that key are grouped together in the Event Stream.source_type_name [optional, default=None]:
The type of event being posted.
Options: nagios, hudson, jenkins, my_apps, chef, puppet, git, bitbucket…related_event_id [optional, default=None]:
ID of the parent event. Must be sent as an integer (i.e. no quotes).device_name [optional, default=None]:
A list of device names to post the event with.SIGNATURE:
POST /v1/events
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
title = "Something big happened!"
text = 'And let me tell you all about it here!'
tags = ['version:1', 'application:web']
api.Event.create(title=title, text=text, tags=tags)
# If you are programmatically adding a comment to this new event
# you might want to insert a pause of .5 - 1 second to allow the
# event to be available.
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# submitting events doesn 't require an application_key,
# so we don't bother setting it
dog = Dogapi::Client.new(api_key)
dog.emit_event(Dogapi::Event.new('msg_text', :msg_title => 'Title'))
# If you are programmatically adding a comment to this new event
# you might want to insert a pause of.5 - 1 second to allow the
# event to be available.api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST -H "Content-type: application/json" \
-d '{
"title": "Did you hear the news today?",
"text": "Oh boy!",
"priority": "normal",
"tags": ["environment:test"],
"alert_type": "info"
}' \
"https://api.datadoghq.com/api/v1/events?api_key=${api_key}"
EXAMPLE RESPONSE:
{
'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 endpoint 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
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/events/<EVENT_ID>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.Event.get(2603387619536318140)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
event_id = '1375909614428331251'
dog.get_event(event_id)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
event_id=<EVENT_ID>
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/events/${event_id}"
EXAMPLE RESPONSE:
{
'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"
}
}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
ARGUMENTS:
start [required]:
POSIX timestamp.end [required]:
POSIX timestamp.priority [optional, default=None]:
Priority of your events: low or normal.sources [optional, default=None]:
A comma separated string of sources.tags [optional, default=None]:
A comma separated string of tags. To use a negative tag filter, prefix your tag with -.
See the Event Stream documentation to learn more.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.SIGNATURE:
GET /v1/events
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
end_time = time.time()
start_time = end_time - 100
api.Event.query(
start=start_time,
end=end_time,
priority="normal",
tags=["-env:dev,application:web"],
unaggregated=True
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
end_time = Time.now.to_i
start_time = end_time - 100
dog.stream(start_time, end_time, :priority => "normal", :tags => ["-env:dev,application:web"], :unaggregated => true)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# Note: this endpoint only accepts form-encoded requests.
currenttime=$(date +%s)
currenttime2=$(date --date='1 day ago' +%s)
curl -X GET \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/events?&start=${currenttime2}&end=${currenttime}&tags=check_type:api&sources=alert&unaggregated=true"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
metric_query [required]:
The metric query.start [required]:
The POSIX timestamp of the start of the query.end [required]:
The POSIX timestamp of the end of the query.event_query [optional, default=None]:
A query that adds event bands to the graph.graph_def [optional, default=None]:
A JSON document defining the graph. 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]:
A title for the graph. If no title is specified, the graph doesn’t have a title.SIGNATURE:
GET /v1/graph/snapshot
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Take a graph snapshot
end = int(time.time())
start = end - (60 * 60)
api.Graph.create(
graph_def='{\
"viz": "timeseries", \
"requests": [ \
{"q": "avg:system.load.1{*}", "conditional_formats": [], "type": "line"},\
{"q": "avg:system.load.5{*}", "type": "line"}, \
{"q": "avg:system.load.15{*}", "type": "line"}\
], \
"events": [\
{"q": "hosts:* ", "tags_execution": "and"}\
]}',
start=start,
end=end
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
end_ts = Time.now().to_i
start_ts = end_ts - (60 * 60)
dog.graph_snapshot("system.load.1{*}", start_ts, end_ts)#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
end_date=$(date +%s)
start_date=$(($end_date - 86400))
curl -X GET \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/snapshot?metric_query=system.load.1\{*\}&start=${start_date}&end=${end_date}"
EXAMPLE RESPONSE:
{
'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 1000 results at a time.
Note: maintenance will not always be set
ARGUMENTS:
filter [optional, default=None]:
Query string to filter search results, for instance: host:<HOSTNAME>.sort_field [optional, default=cpu]:
Sort hosts by the given field.
Options: status, apps, cpu, iowait, 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 1000.from [optional, default=now - 2 hours]:
Number of seconds since UNIX epoch from which you want to search your hosts.SIGNATURE:
GET /v1/hosts
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.Hosts.search()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.search_hosts()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/hosts"
EXAMPLE RESPONSE:
{
"total_returned": 1,
"host_list": [
{
"last_reported_time": 1577786283,
"name": "<HOST_NAME>",
"is_muted": false,
"mute_timeout": null,
"apps": ["docs"],
"tags_by_source": {"Datadog": ["host:<HOST_NAME>"]},
"up": true,
"metrics": {"load": 0.5, "iowait": 3.2, "cpu": 99},
"sources": [],
"meta": {},
"host_name": "<HOST_NAME>",
"id": 1495952100,
"aliases": ["<HOST_NAME>"]
}
],
"total_matching": 1
}
{
"total_returned": 1,
"host_list": [
{
"last_reported_time": 1577786283,
"name": "<HOST_NAME>",
"is_muted": false,
"mute_timeout": null,
"apps": ["docs"],
"tags_by_source": {"Datadog": ["host:<HOST_NAME>"]},
"up": true,
"metrics": {"load": 0.5, "iowait": 3.2, "cpu": 99},
"sources": [],
"meta": {},
"host_name": "<HOST_NAME>",
"id": 1495952100,
"aliases": ["<HOST_NAME>"]
}
],
"total_matching": 1
}
{
"total_returned": 1,
"host_list": [
{
"last_reported_time": 1577786283,
"name": "<HOST_NAME>",
"is_muted": false,
"mute_timeout": null,
"apps": ["docs"],
"tags_by_source": {"Datadog": ["host:<HOST_NAME>"]},
"up": true,
"metrics": {"load": 0.5, "iowait": 3.2, "cpu": 99},
"sources": [],
"meta": {},
"host_name": "<HOST_NAME>",
"id": 1495952100,
"aliases": ["<HOST_NAME>"]
}
],
"total_matching": 1
}
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.
ARGUMENTS:
from [optional, default=now - 2 hours]:
Number of seconds since UNIX epoch from which you want to get the total number of active and up hosts.SIGNATURE:
GET /v1/hosts/totals
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.Hosts.totals()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.host_totals()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/hosts/totals"
EXAMPLE RESPONSE:
{'total_up':1750,'total_active':1759}
["200", {"total_up":1750,"total_active":1759}]
{"total_up":1750,"total_active":1759}
ARGUMENTS:
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.SIGNATURE:
POST /v1/host/<HOSTNAME>/mute
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Find a host to mute
hosts = api.Hosts.search(q='hosts:')
# Mute a host
api.Host.mute(hosts['results']['hosts'][0])
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
hostname = "test.host"
message = "Muting this host for a test."
end_ts = Time.now.to_i + 60 * 60
dog.mute_host(hostname, :message => message, :end => end_ts)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"message": "Muting this host for a test!"
}' \
"https://api.datadoghq.com/api/v1/host/test.host/mute"
EXAMPLE RESPONSE:
{
'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!"
}
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
POST /v1/host/<HOSTNAME>/unmute
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Find a host to unmute
hosts = api.Hosts.search(q='hosts:')
# Unmute host
api.Host.unmute(hosts['results']['hosts'][0])
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
hostname = "test.host"
dog.unmute_host(hostname)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json"
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/host/test.host/unmute"
EXAMPLE RESPONSE:
{
'action': 'Unmuted',
'hostname': 'test.host'
}
["200", {
"action" => "Unmuted",
"hostname" => "test.host"
}]{
"action": "Unmuted",
"hostname": "test.host"
}Configure your Datadog-AWS integration directly through Datadog API. For more information, see the AWS integration page.
List all Datadog-AWS integrations available in your Datadog organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/aws
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AwsIntegration.list()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_integration_list
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# List AWS Accounts (role-based only) in Datadog
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/aws"
EXAMPLE RESPONSE:
{u'accounts':
[{
u'errors': [],
u'filter_tags': [u'filter:example'],
u'host_tags': [u'hosttag:example'],
u'account_specific_namespace_rules': {u'namespace1': False, u'namespace2': False},
u'role_name': u'<DD_AWS_ROLE_NAME>',
u'account_id': u'<DD_AWS_ACCOUNT_ID>'
}]
}
{
"accounts" => [{
"errors" => [],
"account_id" => "<AWS_ACCOUNT_ID>",
"host_tags" => ["<KEY>:<VALUE>"],
"account_specific_namespace_rules" => {},
"role_name" => "DatadogAWSIntegrationRole",
"filter_tags" => ["<KEY>:<VALUE>"]
}]
}
{"accounts":
[{
"account_id": '112233445566',
"role_name": "SomeDatadogRole",
"filter_tags": ["filter123"],
"host_tags": ["account":"demo"],
"account_specific_namespace_rules": {"opsworks":false}
}]
}
Create a Datadog-Amazon Web Services integration.
Note: Using the POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
role_name [required]:
Your Datadog role delegation name. For more information about you AWS account Role name, see the Datadog AWS integration configuration info.
access_key_id [required]:
Your AWS access key ID. Only required if your AWS account is a GovCloud or China account.
secret_access_key [required]:
Your AWS secret access key. Only required if your AWS account is a GovCloud or China account.
filter_tags [optional, default=None]:
The array of EC2 tags (in the form key:value) defines a filter that Datadog uses when collecting metrics from EC2. Wildcards, such as ? (for single characters) and * (for multiple characters) can also be used.
Only hosts that match one of the defined tags will be imported into Datadog. The rest will be ignored. Host matching a given tag can also be excluded by adding ! before the tag.
e.x. env:production,instance-type:c1.*,!region:us-east-1
For more information on EC2 tagging, see the AWS tagging documentation.
host_tags [optional, default=None]:
Array of tags (in the form key:value) to add to all hosts and metrics reporting through this integration.
account_specific_namespace_rules [optional, default=None]:
An object (in the form {"namespace1":true/false, "namespace2":true/false}) that enables or disables metric collection for specific AWS namespaces for this AWS account only. A list of namespaces can be found at the /v1/integration/aws/available_namespace_rules endpoint.
excluded_regions [optional, default=None]:
An array of AWS regions to exclude from metrics collection.
SIGNATURE:
POST /v1/integration/aws
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AwsIntegration.create(
account_id="<AWS_ACCOUNT_ID>",
host_tags=["tag:example"],
filter_tags=["filter:example"],
role_name="<AWS_ROLE_NAME>",
account_specific_namespace_rules={'namespace1': True/False, 'namespace2': True/False},
excluded_regions=["us-east-1", "us-west-1"]
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"account_id": "<AWS_ACCOUNT_ID>",
"filter_tags": ["<KEY>:<VALUE>"],
"host_tags": ["<KEY>:<VALUE>"],
"role_name": "DatadogAWSIntegrationRole",
"account_specific_namespace_rules": {"auto_scaling": false, "opsworks": false},
"excluded_regions": ["us-east-1", "us-west-1"]
}
dog.aws_integration_create(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# Create an AWS Account in Datadog
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"filter_tags": ["<KEY>:<VALUE>"],
"host_tags": ["<KEY>:<VALUE>"],
"role_name": "DatadogAWSIntegrationRole",
"account_specific_namespace_rules": {
"auto_scaling": false,
"opsworks": false
},
"excluded_regions": ["us-east-1", "us-west-1"]
}'\
"https://api.datadoghq.com/api/v1/integration/aws"
EXAMPLE RESPONSE:
{
"external_id": "12345678910111213"
}
{
"external_id"=> "12345678910111213"
}
{
"external_id": "12345678910111213"
}
Update a Datadog-Amazon Web Services integration.
QUERY PARAMS [curl only]:
account_id [required]:
Your Existing AWS Account ID without dashes. It needs to be passed as query parameter. Only required for Role based account configuration. Consult the Datadog AWS integration to learn more about your AWS account ID.
role_name [required]:
Your Existing Datadog role delegation name. It needs to be passed as query parameter. Only required for Role based account configuration. For more information about your AWS account Role name, see the Datadog AWS integration configuration info.
access_key_id [required]:
Your Existing AWS access key ID. Only required if your AWS account is a GovCloud or China account, enter the existing corresponding Access Key ID to be changed. It needs to be passed as query parameter.
secret_access_key [required]:
Your Existing AWS secret access key. Only required if your AWS account is a GovCloud or China account, enter the corresponding Access Key ID. It needs to be passed as query parameter.
CURL SPECIFIC ARGUMENTS:
account_id [optional, curl only]:
Your New AWS Account ID without dashes. It needs to be passed as an argument. Consult the Datadog AWS integration to learn more about your AWS account ID.
role_name [optional, curl only]:
Your New Datadog role delegation name. It needs to be passed as an argument. For more information about your AWS account Role name, see the Datadog AWS integration configuration info.
access_key_id [optional, curl only]:
Your New AWS access key ID. Only applicable if your AWS account is a GovCloud or China account.
secret_access_key [optional, curl only]:
Your New AWS secret access key. Only required if your AWS account is a GovCloud or China account.
ARGUMENTS:
account_id [required, Python and Ruby]:
Your Existing AWS Account ID without dashes. It needs to be passed as an argument. Consult the Datadog AWS integration to learn more about your AWS account ID.
role_name [required, Python and Ruby]:
Your Existing Datadog role delegation name. It needs to be passed as an argument. For more information about your AWS account Role name, see the Datadog AWS integration configuration info.
access_key_id [required, Python and Ruby]:
Your Existing AWS access key ID. Only required if your AWS account is a GovCloud or China account.
secret_access_key [required, Python and Ruby]:
Your Existing AWS secret access key. Only required if your AWS account is a GovCloud or China account.
new_account_id [optional, Python and Ruby]:
Your New AWS Account ID without dashes. It needs to be passed as an argument. Consult the Datadog AWS integration to learn more about your AWS account ID.
new_role_name [optional, Python and Ruby]:
Your New Datadog role delegation name. It needs to be passed as an argument. For more information about your AWS account Role name, see the Datadog AWS integration configuration info.
new_access_key_id [optional, Python and Ruby]:
Your New AWS access key ID. Only applicable if your AWS account is a GovCloud or China account.
new_secret_access_key [optional, Python and Ruby]:
Your New AWS secret access key. Only applicable if your AWS account is a GovCloud or China account.
filter_tags [optional, default=None]:
The array of EC2 tags (in the form key:value) defines a filter that Datadog uses when collecting metrics from EC2. Wildcards, such as ? (for single characters) and * (for multiple characters) can also be used.
Only hosts that match one of the defined tags are imported into Datadog. The rest are ignored. Host matching a given tag can also be excluded by adding ! before the tag.
e.x. env:production,instance-type:c1.*,!region:us-east-1
For more information on EC2 tagging, see the AWS tagging documentation.
host_tags [optional, default=None]:
Array of tags (in the form key:value) to add to all hosts and metrics reporting through this integration.
account_specific_namespace_rules [optional, default=None]:
An object (in the form {"namespace1":true/false, "namespace2":true/false}) that enables or disables metric collection for specific AWS namespaces for this AWS account only. A list of namespaces can be found at the /v1/integration/aws/available_namespace_rules endpoint.
excluded_regions [optional, default=None]:
An array of AWS regions to exclude from metrics collection.
SIGNATURE:
PUT /v1/integration/aws
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# For account_id/role_name
api.AwsIntegration.update(
account_id="<EXISTING_AWS_ACCOUNT_ID>",
role_name="<EXISTING_AWS_ROLE_NAME>",
new_account_id="<NEW_AWS_ACCOUNT_ID>",
new_role_name="<NEW_AWS_ROLE_NAME>",
host_tags=["hosttag:example"],
filter_tags=["filter:example"],
account_specific_namespace_rules = {"namespace1":True/False, "namespace2":True/False},
excluded_regions=["us-east-1", "us-west-1"]
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
# Existing configuration goes here.
config = {
"account_id": "<AWS_ACCOUNT_ID>",
"role_name": 'DatadogAWSIntegrationRole'
}
# New configuration goes here.
new_config = {
"account_id": '<NEW_AWS_ACCOUNT_ID>',
"host_tags": ["<KEY>:<VALUE>"],
"filter_tags": ["<KEY>:<VALUE>"],
"role_name": '<NEW_AWS_ROLE_NAME>',
"excluded_regions": ["us-east-1", "us-west-1"]
}
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_integration_update(config, new_config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# Update an AWS Account in Datadog
curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"filter_tags": [
"<TAG_KEY>:<TAG_VALUE>"
],
"host_tags": [
"<TAG_KEY>:<TAG_VALUE>"
],
"account_specific_namespace_rules": {
"auto_scaling": false,
"opsworks": false
},
"excluded_regions": ["us-east-1", "us-west-1"]
}' \
"https://api.datadoghq.com/api/v1/integration/aws?account_id=<YOUR_AWS_ACCOUNT_ID>&role_name=<ROLE_NAME>"
EXAMPLE RESPONSE:
{}{}
{}
Delete a given Datadog-AWS integration.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
role_name [required]:
Your Datadog role delegation name. For more information about you AWS account Role name, see the Datadog AWS integration configuration info.
SIGNATURE:
DELETE /v1/integration/aws
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID>"
role_name = "<AWS_ROLE_NAME>"
api.AwsIntegration.delete(account_id=account_id, role_name=role_name)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"role_name": 'DatadogAWSIntegrationRole'
}
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_integration_delete(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# Delete an AWS Account in Datadog
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"role_name": "DatadogAWSIntegrationRole"
}' \
"https://api.datadoghq.com/api/v1/integration/aws"
EXAMPLE RESPONSE:
{}{}
{}List all namespace rules for a given Datadog-AWS integration.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/aws/available_namespace_rules
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AwsIntegration.list_namespace_rules()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_integration_list_namespaces
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# List available namespace rules
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/aws/available_namespace_rules"
EXAMPLE RESPONSE:
[u'api_gateway', u'application_elb', u'appstream', u'appsync', u'athena', u'auto_scaling', u'billing', u'budgeting', u'cloudfront', u'cloudhsm', u'cloudsearch', u'cloudwatch_events', u'cloudwatch_logs', u'codebuild', u'cognito', u'collect_custom_metrics', u'connect', u'crawl_alarms', u'directconnect', u'dms', u'documentdb', u'dynamodb', u'ebs', u'ec2', u'ec2api', u'ec2spot', u'ecs', u'efs', u'elasticache', u'elasticbeanstalk', u'elastictranscoder', u'elb', u'emr', u'es', u'firehose', u'gamelift', u'glue', u'inspector', u'iot', u'kinesis', u'kinesis_analytics', u'kms', u'lambda', u'lex', u'mediaconnect', u'mediaconvert', u'mediapackage', u'mediatailor', u'ml', u'mq', u'msk', u'nat_gateway', u'neptune', u'network_elb', u'opsworks', u'polly', u'rds', u'redshift', u'rekognition', u'route53', u'route53resolver', u's3', u'sagemaker', u'ses', u'shield', u'sns', u'sqs', u'step_functions', u'storage_gateway', u'swf', u'translate', u'trusted_advisor', u'vpn', u'waf', u'workspaces', u'xray']
["api_gateway", "application_elb", "appstream", "appsync", "athena", "auto_scaling", "billing", "budgeting", "cloudfront", "cloudhsm", "cloudsearch", "cloudwatch_events", "cloudwatch_logs", "codebuild", "cognito", "collect_custom_metrics", "connect", "crawl_alarms", "directconnect", "dms", "documentdb", "dynamodb", "ebs", "ec2", "ec2api", "ec2spot", "ecs", "efs", "elasticache", "elasticbeanstalk", "elastictranscoder", "elb", "emr", "es", "firehose", "gamelift", "glue", "inspector", "iot", "kinesis", "kinesis_analytics", "kms", "lambda", "lex", "mediaconnect", "mediaconvert", "mediapackage", "mediatailor", "ml", "mq", "msk", "nat_gateway", "neptune", "network_elb", "opsworks", "polly", "rds", "redshift", "rekognition", "route53", "route53resolver", "s3", "sagemaker", "ses", "shield", "sns", "sqs", "step_functions", "storage_gateway", "swf", "translate", "trusted_advisor", "vpn", "waf", "workspaces", "xray"]
["api_gateway","application_elb","appsync","auto_scaling","billing","budgeting","cloudfront","cloudsearch","cloudwatch_events","cloudwatch_logs","codebuild","collect_custom_metrics","crawl_alarms","ddos_protection","directconnect","dms","documentdb","dynamodb","ebs","ec2","ec2api","ec2spot","ecs","efs","elasticache","elasticbeanstalk","elastictranscoder","elb","emr","es","firehose","gamelift","iot","kinesis","kinesis_analytics","kms","lambda","lex","ml","mq","nat_gateway","network_elb","opsworks","polly","rds","redshift","rekognition","route53","s3","sagemaker","ses","sns","sqs","state_machine","storage_gateway","swf","vpn","waf","workspaces","xray"]Generate a new AWS external id for a given AWS account id and role name pair.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
role_name [required]:
Your Datadog role delegation name. For more information about your AWS account Role name, see the Datadog AWS integration configuration info.
SIGNATURE:
PUT /v1/integration/aws/generate_new_external_id
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID>"
role_name = "<AWS_ROLE_NAME>"
api.AwsIntegration.generate_new_external_id(account_id=account_id, role_name=role_name)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"role_name": 'DatadogAWSIntegrationRole'
}
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_integration_generate_external_id(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H "Content-type: application/json"
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d
'{
"account_id": "<YOUR_AWS_ACCOUNT_ID>",
"role_name": "DatadogAWSIntegrationRole"
}' \
"https://dd.datadoghq.com/api/v1/integration/aws/generate_new_external_id"
EXAMPLE RESPONSE:
{u'external_id': u'<NEW_EXTERNAL_ID>'}{
"external_id"=> "12345678910111213"
}
{}Configure your Datadog-AWS-Logs integration directly through Datadog API. For more information, see the AWS integration page.
List all Datadog-AWS logs integrations available in your Datadog organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/aws/logs
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AwsLogsIntegration.list()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_logs_integrations_list
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET "https://api.datadoghq.com/api/v1/integration/aws/logs?api_key=${api_key}&application_key=${app_key}"
EXAMPLE RESPONSE:
[{u'services': [u'list', u'of', u'enabled', u'services'], u'account_id': u'<AWS_ACCOUNT_ID>', u'lambdas': []}]# Nothing here yet.# Nothing here yet.Get the list of current AWS services for which Datadog offers automatic log collection. Use returned service IDs with the services parameter for the Enable an AWS service log collection API endpoint.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/aws/logs/services
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AwsLogsIntegration.list_log_services()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.aws_logs_list_services
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/aws/logs/services"
EXAMPLE RESPONSE:
[{u'id': u's3', u'label': u'S3 Access Logs'}, {u'id': u'elb', u'label': u'Classic ELB Access Logs'}, {u'id': u'elbv2', u'label': u'Application ELB Access Logs'}, {u'id': u'cloudfront', u'label': u'CloudFront Access Logs'}, {u'id': u'redshift', u'label': u'Redshift Logs'}, {u'id': u'lambda', u'label': u'Lambda Cloudwatch Logs'}][{"id"=>"s3", "label"=>"S3 Access Logs"}, {"id"=>"elb", "label"=>"Classic ELB Access Logs"}, {"id"=>"elbv2", "label"=>"Application ELB Access Logs"}, {"id"=>"cloudfront", "label"=>"CloudFront Access Logs"}, {"id"=>"redshift", "label"=>"Redshift Logs"}, {"id"=>"lambda", "label"=>"Lambda Cloudwatch Logs"}][{"id":"s3","label":"S3 Access Logs"},{"id":"elb","label":"Classic ELB Access Logs"},{"id":"elbv2","label":"Application ELB Access Logs"},{"id":"cloudfront","label":"CloudFront Access Logs"},{"id":"redshift","label":"Redshift Logs"},{"id":"lambda","label":"Lambda Cloudwatch Logs"}]Attach the Lambda ARN of the Lambda created for the Datadog-AWS log collection to your AWS account ID to enable log collection.
In order to enable the newly added Lambda, use the Enable an AWS service log collection endpoint.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
lambda_arn [required]:
ARN of the Datadog Lambda created during the Datadog-Amazon Web services Log collection setup.
SIGNATURE:
POST /v1/integration/aws/logs
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID>"
lambda_arn = "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>"
api.AwsLogsIntegration.add_log_lambda_arn(account_id=account_id, lambda_arn=lambda_arn)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"lambda_arn": 'arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>'
}
dog.aws_logs_add_lambda(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"lambda_arn": "arn:aws:lambda:us-east-1:123456789012:function:PushLogs"
}'\
"https://api.datadoghq.com/api/v1/integration/aws/logs"
EXAMPLE RESPONSE:
{}{}{}Enable Automatic Log collection for your AWS services.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
services [required]: Array of services IDs set to enable automatic log collection. Discover the list of available services with the Get list of AWS log ready services API endpoint
SIGNATURE:
POST /v1/integration/aws/logs/services
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID"
services = ["s3", "elb", "elbv2", "cloudfront", "redshift", "lambda"]
api.AwsLogsIntegration.save_services(account_id=account_id, services=services)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"services": ['s3', 'elb', 'elbv2', 'cloudfront', 'redshift', 'lambda']
}
dog.aws_logs_save_services(config)#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-H "Content-type: application/json" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"services": ["elb","s3"]
}'\
"https://api.datadoghq.com/api/v1/integration/aws/logs/services"
EXAMPLE RESPONSE:
{}{}{}Delete a Datadog-AWS logs configuration by removing the specific Lambda ARN associated with a given AWS account.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
lambda_arn [required]:
ARN of the Datadog Lambda created during the Datadog-Amazon Web services Log collection setup.
SIGNATURE:
DELETE /v1/integration/aws/logs
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID>"
lambda_arn = "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>"
api.AwsLogsIntegration.delete_config(account_id=account_id, lambda_arn=lambda_arn)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"lambda_arn": 'arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>'
}
dog.aws_logs_integration_delete(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"lambda_arn": "arn:aws:lambda:us-east-1:123456789012:function:PushLogs"
}'\
"https://api.datadoghq.com/api/v1/integration/aws/logs"
EXAMPLE RESPONSE:
{}{}{}Check function that verifies whether a given Lambda exists within a given AWS account. This endpoint can be polled continuously without blocking.
created when it’s checking if the Lambda exists in the account.waiting while checking.checked and ok if the Lambda exists.error if the Lambda does not exist.Note: You must have the given AWS account configured in the main AWS Integration tile for this to successfully verify.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
lambda_arn [required]:
ARN of the Datadog Lambda created during the Datadog-Amazon Web services Log collection setup.
SIGNATURE:
POST /v1/integration/aws/logs/check_async
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID>"
lambda_arn = "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<FUNCTION_NAME>"
api.AwsLogsIntegration.check_lambda(account_id=account_id, lambda_arn=lambda_arn)require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"lambda_arn": 'arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>'
}
dog.aws_logs_check_lambda(config)#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST -H "Content-type: application/json" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"lambda_arn": "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<FUNCTION_NAME>"
}' \
"https://api.datadoghq.com/api/v1/integration/aws/logs/check_async?api_key=${api_key}&application_key=${app_key}"
EXAMPLE RESPONSE:
{u'status': u'<STATUS>'}{"status"=>"<STATUS>"}{"status":"<STATUS>"}Test if permissions are present to add a log-forwarding triggers for the given services and AWS account. The input is the same as for Enable an AWS service log collection.
The call is done asynchronously, so can be repeatedly polled in a non-blocking fashion until the asynchronous request completes.
created when initialized.waiting while checking.checked and ok if the permissions exist.error if the permissions do not exist.Note: You must have the given AWS Lambda configured in the main AWS Integration tiles logs tab for this to successfully verify.
ARGUMENTS:
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
services [required]: Array of services IDs set to enable automatic log collection. Discover the list of available services with the Get list of AWS log ready services API endpoint
SIGNATURE:
POST /v1/integration/aws/logs/services_async
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
account_id = "<AWS_ACCOUNT_ID"
services = ["s3", "elb", "elbv2", "cloudfront", "redshift", "lambda"]
api.AwsLogsIntegration.check_services(account_id=account_id, services=services)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"account_id": '<AWS_ACCOUNT_ID>',
"services": ['s3', 'elb', 'elbv2', 'cloudfront', 'redshift', 'lambda']
}
dog.aws_logs_check_services(config)#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST -H "Content-type: application/json" \
-d '{
"account_id": "AWS_ACCOUNT_ID",
"services": ["s3", "elb", "elbv2", "cloudfront", "redshift", "lambda"]
}' \
"https://api.datadoghq.com/api/v1/integration/aws/logs/services_async?api_key=${api_key}&application_key=${app_key}"
EXAMPLE RESPONSE:
{u'status': u'<STATUS>'}{"status"=>"<STATUS>"}{"status":"<STATUS>"}Configure your Datadog-Azure integration directly through the Datadog API. For more information, see the Datadog-Azure integration page.
List all Datadog-Azure integrations configured for your organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/azure
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AzureIntegration.list()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.azure_integration_list
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/azure"
EXAMPLE RESPONSE:
[{u'tenant_name': u'<configured_tenant_name>', u'errors': [], u'client_id': u'<configured_client_id>', u'host_filters': u'current:filters'}]
{
"tenant_name" => "<AZURE_TENANT_NAME>",
"errors" => [],
"host_filters" => "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>",
"client_id" => "<AZURE_CLIENT_ID>"
}
OKCreate a Datadog-Azure 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.ARGUMENTS:
Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.
tenant_name [required]:
Your Azure Active Directory ID.
client_id [required]:
Your Azure web application ID.
client_secret [required]:
Your Azure web application secret key.
host_filters [optional, default=None]:
Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.
SIGNATURE:
POST /v1/integration/azure
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AzureIntegration.create(
tenant_name="<AZURE_TENANT_NAME>",
host_filters="<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>",
client_id="<AZURE_CLIENT_ID>",
client_secret="<AZURE_CLIENT_SECRET>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"client_secret": "<AZURE_CLIENT_SECRET>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}
dog = Dogapi::Client.new(api_key, app_key)
dog.azure_integration_create(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
# Create an Azure account in Datadog
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"client_secret": "<AZURE_CLIENT_SECRET>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://api.datadoghq.com/api/v1/integration/azure"
EXAMPLE RESPONSE:
{}{}
OKDelete a given Datadog-Azure integration.
ARGUMENTS:
Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.
tenant_name [required]:
Your Azure Active Directory ID.
client_id [required]:
Your Azure web application ID.
host_filters [optional, default=None]:
Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.
SIGNATURE:
DELETE /v1/integration/azure
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AzureIntegration.delete(
tenant_name="<AZURE_TENANT_NAME>",
client_id="<AZURE_CLIENT_ID>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"tenant_name": '<AZURE_TENANT_NAME>',
"client_id": '<AZURE_CLIENT_ID>'
}
dog.azure_integration_delete(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>"
}' \
"https://api.datadoghq.com/api/v1/integration/azure"
EXAMPLE RESPONSE:
{}{}
OKUpdate the defined list of host filters for a given Datadog-Azure integration.
ARGUMENTS:
Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.
tenant_name [required]:
Your Azure Active Directory ID.
client_id [required]:
Your Azure web application ID.
client_secret [required]:
Your Azure web application secret key.
host_filters [optional, default=None]:
Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.
SIGNATURE:
POST /v1/integration/azure/host_filters
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AzureIntegration.update_host_filters(
tenant_name="<AZURE_TENANT_NAME>",
host_filters="new:filters",
client_id="<AZURE_CLIENT_ID>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"host_filters": "<NEW_KEY>:<NEW_VALUE>"
}
dog = Dogapi::Client.new(api_key, app_key)
dog.azure_integration_update_host_filters(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"client_secret": "<AZURE_CLIENT_SECRET>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://api.datadoghq.com/api/v1/integration/azure/host_filters"
EXAMPLE RESPONSE:
{}
{}
OKUpdate the Datadog-Azure integration.
ARGUMENTS:
Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.
tenant_name [required]:
Your Existing Azure Active Directory ID.
new_tenant_name [optional]:
Your New Azure Active Directory ID.
client_id [required]:
Your Existing Azure web application ID.
new_client_id [optional]:
Your New Azure web application ID.
client_secret [required]:
Your Azure web application secret key.
host_filters [optional, default=None]:
Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.
SIGNATURE:
PUT /v1/integration/azure
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.AzureIntegration.update(
tenant_name="<EXISTING_AZURE_TENANT_NAME>",
new_tenant_name="<NEW_AZURE_TENANT_NAME>",
host_filters="new:filters",
client_id="<EXISTING_AZURE_CLIENT_ID>",
new_client_id="<NEW_AZURE_CLIENT_ID>",
client_secret="<EXISTING_CLIENT_SECRET>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"tenant_name": "<AZURE_TENANT_NAME>",
"new_tenant_name": "<NEW_AZURE_TENANT_NAME>",
"host_filters": "new:filters",
"client_id": "<AZURE_CLIENT_ID>",
"new_client_id": "<NEW_AZURE_CLIENT_ID>",
"client_secret": "<AZURE_CLIENT_SECRET>"
}
dog.azure_integration_update(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT -H "Content-type: application/json" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"new_tenant_name": "<NEW_AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"new_client_id": "<NEW_AZURE_CLIENT_ID>",
"client_secret": "<AZURE_CLIENT_SECRET>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://api.datadoghq.com/api/v1/integration/azure?api_key=${api_key}&application_key=${app_key}"
EXAMPLE RESPONSE:
{}
{}
{}
Configure your Datadog-Google Cloud Platform (GCP) integration directly through the Datadog API. Read more about Datadog-Google Cloud Platform integration.
List all Datadog-GCP integrations configured for your organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/gcp
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.list()
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.gcp_integration_list
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/gcp"
EXAMPLE RESPONSE:
[{u'automute': True||False, u'project_id': u'<GCP_PROJECT_ID>', u'client_email': u'<GCP_CLIENT_EMAIL>', u'errors': [], u'host_filters': u'current:filters'}]
{
"automute" => false,
"project_id" => "<GCP_PROJECT_ID>",
"client_email" => "<CLIENT_EMAIL>",
"errors" => [],
"host_filters" => "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}
OKCreate a Datadog-Google Cloud Platform 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.ARGUMENTS:
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]:
The value for service_account 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.
SIGNATURE:
POST /v1/integration/gcp
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.create(
type="service_account",
project_id="<GCP_PROJECT_ID>",
private_key_id="<GCP_PRIVATE_KEY_ID>",
private_key="<GCP_PRIVATE_KEY>",
client_email="<GCP_CLIENT_EMAIL>",
client_id="<GCP_CLIENT_ID>",
auth_uri="<GCP_AUTH_URI>",
token_uri="<GCP_TOKEN_URI>",
auth_provider_x509_cert_url="<GCP_AUTH_PROVIDER_X509_CERT_URL>",
client_x509_cert_url="<GCP_CLIENT_X509_CERT_URL>",
host_filters="<KEY>:<VALUE>,<KEY>:<VALUE>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"type": "service_account",
"project_id": "<GCP_PROJECT_ID>",
"private_key_id": "<PRIVATE_KEY_ID>",
"private_key": "<PRIVATE_KEY>",
"client_email": "<CLIENT_EMAIL>",
"client_id": "<CLIENT_ID>",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://accounts.google.com/o/oauth2/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}
dog = Dogapi::Client.new(api_key, app_key)
dog.gcp_integration_create(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"type": "service_account",
"project_id": "<GCP_PROJECT_ID>",
"private_key_id": "<PRIVATE_KEY_ID>",
"private_key": "<PRIVATE_KEY>",
"client_email": "<CLIENT_EMAIL>",
"client_id": "<CLIENT_ID>",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://accounts.google.com/o/oauth2/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://api.datadoghq.com/api/v1/integration/gcp"
EXAMPLE RESPONSE:
{}
{}
OKDelete a given Datadog-GCP integration.
ARGUMENTS:
project_id [required]:
Your Google Cloud project ID found in your JSON service account key.
client_email [required]:
Your email found in your JSON service account key.
SIGNATURE:
DELETE /v1/integration/gcp
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.delete(
project_id="<GCP_PROJECT_ID>",
client_email="<GCP_CLIENT_EMAIL>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<GCP_CLIENT_EMAIL>"
}
dog.gcp_integration_delete(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<CLIENT_EMAIL>"
}' \
"https://api.datadoghq.com/api/v1/integration/gcp"
EXAMPLE RESPONSE:
{}
{}
OKUpdate endpoint for GCP allowing you to enable or disable automute for a given Datadog-GCP integration, as well as modify host_filters.
ARGUMENTS:
project_id [required]:
Your Google Cloud project ID found in your JSON service account key.
client_email [required]:
Your email found in your JSON service account key.
automute [optional, default=false]:
Silence monitors for expected GCE instance shutdowns.
host_filters [optional]:
Limit the GCE instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.
SIGNATURE:
PUT /v1/integration/gcp
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.update(
project_id="<GCP_PROJECT_ID>",
client_email="<GCP_CLIENT_EMAIL>",
automute=True,
host_filters="<NEW>:<FILTERS>"
)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<GCP_CLIENT_EMAIL>",
"automute": true,
"host_filters": "<NEW>:<FILTERS>"
}
dog = Dogapi::Client.new(api_key, app_key)
dog.gcp_integration_update(config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<CLIENT_EMAIL>",
"automute": <AUTOMUTE>,
"host_filters": "<NEW>:<FILTERS>"
}' \
"https://api.datadoghq.com/api/v1/integration/gcp"
EXAMPLE RESPONSE:
{}
{}
OKThe PagerDuty endpoints are not supported in Datadog’s Python client library. To request this functionality, contact Datadog Support.
Configure your Datadog-PagerDuty integration directly through the Datadog API. For more informations, see the PagerDuty integration page.
Get all information about your Datadog-PagerDuty integration.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/pagerduty
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.get_integration('pagerduty')
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/pagerduty"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
"services" => [{
"service_name" => "<SERVICE_NAME_1>",
"service_key" => "*****"
}, {
"service_name" => "<SERVICE_NAME_2>",
"service_key" => "*****"
}], "schedules" => ["<SCHEDULE_1>", "<SCHEDULE_2>"],
"subdomain" => "<PAGERDUTY_SUB_DOMAIN>",
"api_token" => "*****"
}
OKCreate a new 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. All arguments are required when creating (PUT) a new PagerDuty configuration.ARGUMENTS:
services :
The array of PagerDuty service objects. Learn how to configure your Datadog service with the PagerDuty documentation. A PagerDuty service object is composed by:
service_name [required]:
Your Service name in PagerDuty.
service_key [required]:
Your Service name associated service key in Pagerduty.
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.
SIGNATURE:
PUT /v1/integration/pagerduty
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"services": [
{
"service_name": "<SERVICE_NAME_1>",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
},
{
"service_name": "<SERVICE_NAME_2>",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
}
],
"subdomain": "<PAGERDUTY_SUB_DOMAIN>",
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
"api_token": "<PAGERDUTY_TOKEN>"
}
dog = Dogapi::Client.new(api_key, app_key)
dog.create_integration('pagerduty', config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"services": [
{
"service_name": "<SERVICE_NAME_1>",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
},
{
"service_name": "<SERVICE_NAME_2>",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
}
],
"subdomain": "<PAGERDUTY_SUB_DOMAIN>",
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
"api_token": "<PAGERDUTY_TOKEN>"
}' \
"https://api.datadoghq.com/api/v1/integration/pagerduty"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OKAdd new services and schedules to your 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.ARGUMENTS:
services :
The array of PagerDuty service objects. Learn how to configure your Datadog service with the PagerDuty documentation. A PagerDuty service object is composed by:
service_name [required]:
Your Service name in PagerDuty.
service_key [required]:
Your Service name associated service key in Pagerduty.
schedules :
The array of your schedule URLs:
["https://my-pd.pagerduty.com/schedules#PCPYT4M", "https://my-pd.pagerduty.com/schedules#PKTPB7P"]
SIGNATURE:
PUT /v1/integration/pagerduty
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"services": [
{
"service_name": "test_00",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
},
{
"service_name": "test_01",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
}
],
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
}
dog = Dogapi::Client.new(api_key, app_key)
# Warning: this function makes a PUT call to the Datadog API
# It updates your integration configuration by REPLACING
# your current configuration with the new one.
dog.update_integration('pagerduty', config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"services": [
{
"service_name": "test_00",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
},
{
"service_name": "test_01",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
}
],
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
}' \
"https://api.datadoghq.com/api/v1/integration/pagerduty"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OKDelete the Datadog-PagerDuty integration.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/integration/pagerduty
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.delete_integration('pagerduty')
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/pagerduty"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OKThe Slack endpoints are not supported in Datadog’s Python client library. To request this functionality, contact Datadog Support.
Configure your Datadog-Slack integration directly through Datadog API. For more information about the Datadog-Slack integration, see the integration page.
Get all information about your Datadog-Slack integration.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/slack
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.get_integration('slack')
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/slack"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
"channels" => [], "service_hooks" => [{
"url" => "*****",
"account" => "Main_Account"
}, {
"url" => "*****",
"account" => "doghouse"
}]
}
OK
Create a Datadog-Slack integration. Once created, add a channel to it with the Add channels to Slack integration endpoint.
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. All arguments are required when creating (PUT) a new Slack configuration.ARGUMENTS:
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.
SIGNATURE:
POST /v1/integration/slack
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"service_hooks": [
{
"account": "Main_Account",
"url": "https://hooks.slack.com/services/1/1/1"
},
{
"account": "doghouse",
"url": "https://hooks.slack.com/services/2/2/2"
}
]
}
dog = Dogapi::Client.new(api_key, app_key)
dog.create_integration('slack', config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"service_hooks": [
{
"account": "Main_Account",
"url": "https://hooks.slack.com/services/1/1/1"
},
{
"account": "doghouse",
"url": "https://hooks.slack.com/services/2/2/2"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/slack"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK
Add channels to your 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.ARGUMENTS:
channels [required]:
The array of slack channel objects to post to. A slack channel object is composed by:
channel_name [required]:
Your channel name e.g: #general, #private
transfer_all_user_comments [optional, default=False]:
To be notified for every comment on a graph, set it to true. If set to False use the @slack-channel_name syntax for comments to be posted to slack.
account [required]:
Account to which the channel belongs to.
SIGNATURE:
PUT /v1/integration/slack
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"channels": [
{
"channel_name": "#channel_name_main_account",
"transfer_all_user_comments": "false",
"account": "Main_Account"
},
{
"channel_name": "#channel_name_doghouse",
"transfer_all_user_comments": "false",
"account": "doghouse"
}
]
}
dog = Dogapi::Client.new(api_key, app_key)
# Warning: this function makes a PUT call to the Datadog API
# It updates your integration configuration by REPLACING
# your current configuration with the new one.
dog.update_integration('slack', config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"channels": [
{
"channel_name": "#channel_name_main_account",
"transfer_all_user_comments": "false",
"account": "Main_Account"
},
{
"channel_name": "#channel_name_doghouse",
"transfer_all_user_comments": "false",
"account": "doghouse"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/slack"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK
Delete a Datadog-Slack integration.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/integration/slack
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.delete_integration('slack')
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/slack"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK
The Webhooks endpoints are not supported in Datadog’s Python client library. To request this functionality, contact Datadog Support.
Configure your Datadog-Webhooks integration directly through the Datadog API. For more information about the Datadog-Webhooks integration, see the integration page.
Get all Datadog-Webhooks integration information.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/integration/webhooks
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.get_integration('webhooks')
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/webhooks"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
"hooks" => [{
"custom_payload" => "",
"name" => "Example",
"url" => "http://example.com",
"encode_as_form" => "false",
"headers" => "",
"use_custom_payload" => "false"
}]
}
OKCreate a 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. All arguments are required when creating (PUT) a new Webhook configuration.ARGUMENTS:
hooks [required]:
Array of Webhook objects. A Webhook object is composed by:
name [required]:
Your Webhook name.
Learn more on how to use it in monitor notifications.url [required]:
Your Webhook URL.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.
SIGNATURE:
POST /v1/integration/webhooks
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"hooks": [
{
"name": "Example",
"url": "http://example.com"
}
]
}
dog = Dogapi::Client.new(api_key, app_key)
dog.create_integration('webhooks', config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"hooks": [
{
"name": "<WEBHOOK_NAME>",
"url": "<WEBHOOK_URL>"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OKAdd a specific Webhook to a 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.ARGUMENTS:
hooks [required]:
Array of Webhook objects. A Webhook object is composed by:
name [required]:
Your Webhook name.
Learn more on how to use it in monitor notifications.url [required]:
Your Webhook URL.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.
SIGNATURE:
PUT /v1/integration/webhooks
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"hooks": [
{
"name": "Example",
"url": "http://example.com/2"
}
]
}
dog = Dogapi::Client.new(api_key, app_key)
# Warning: this function makes a PUT call to the Datadog API
# It updates your integration configuration by REPLACING
# your current configuration with the new one.
dog.update_integration('webhooks', config)
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"hooks": [
{
"name": "<WEBHOOK_NAME>",
"url": "<WEBHOOK_URL>"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OKDelete a given Datadog-Webhooks integration.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/integration/webhooks
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.delete_integration('webhooks')
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -v -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/webhooks"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OKThe Key Management endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.
Manage your Datadog API and application keys.
You need an API and applications key with Admin rights to interact with this endpoint.
The full list of keys can be seen on your Datadog API page.
Get all API keys available for your account.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/api_key/
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/api_key"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"api_keys": [
{
"created_by": "john@example.com",
"name": "<API_KEY_NAME>",
"key": "1111111111111111aaaaaaaaaaaaaaaa",
"created": "2019-04-05 09:20:30"
},
{
"created_by": "jane@example.com",
"name": "<API_KEY_NAME_2>",
"key": "2111111111111111aaaaaaaaaaaaaaaa",
"created": "2019-04-05 09:19:53"
}
]
}
Get a given API key.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/api_key/<API_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_GET>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"api_key": {
"created_by": "john@example.com",
"name": "<API_KEY_NAME>",
"key": "3111111111111111aaaaaaaaaaaaaaaa",
"created": "2019-04-05 09:47:00"
}
}
Create an API key with a given name.
ARGUMENTS:
name [required]:
Name of your API key.
SIGNATURE:
POST /v1/api_key/<API_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name": "<API_KEY_NAME>"
}' \
"https://app.datadoghq.com/api/v1/api_key"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"api_key": {
"created_by": "john@example.com",
"name": "<API_KEY_NAME>",
"key": "3111111111111111aaaaaaaaaaaaaaaa",
"created": "2019-04-05 09:47:00"
}
}
Edit an API key name.
ARGUMENTS:
name [required]:
Name of your API key.
SIGNATURE:
PUT /v1/api_key/<API_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name":"<NEW_API_KEY_NAME>"
}' \
"https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_EDIT>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"api_key": {
"created_by": "john@example.com",
"name": "<API_KEY_NAME>",
"key": "3111111111111111aaaaaaaaaaaaaaaa",
"created": "2019-04-05 09:47:00"
}
}
Delete a given API key.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/api_key/<API_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X DELETE \
-H 'Content-Type: application/json'
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_DELETE>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"api_key": {
"created_by": "john@example.com",
"name": "<API_KEY_NAME>",
"key": "3111111111111111aaaaaaaaaaaaaaaa",
"created": "2019-04-05 09:47:00"
}
}
Get all application keys available for your account.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/application_key/
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/application_key"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"application_keys": [
{
"owner": "john@example.com",
"hash": "11111111111111111111aaaaaaaaaaaaaaaaaaaa",
"name": "<APP_KEY_NAME>"
},
{
"owner": "jane@example.com",
"hash": "21111111111111111111aaaaaaaaaaaaaaaaaaaa",
"name": "<APP_KEY_NAME_2>"
}
]
}
Get a given application key.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/application_key/<DATADOG_APPLICATION_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_GET>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"application_key": {
"owner": "john@example.com",
"hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
"name": "<APP_KEY_NAME>"
}
}
Create an application key with a given name.
ARGUMENTS:
name [required]:
Name of your application key.
SIGNATURE:
POST /v1/application_key/<APP_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name": "<DATADOG_APPLICATION_KEY_NAME>"
}' \
"https://app.datadoghq.com/api/v1/application_key"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"application_key": {
"owner": "john@example.com",
"hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
"name": "<APP_KEY_NAME>"
}
}
Edit an application key name.
ARGUMENTS:
name [required]:
Name of your application key.
SIGNATURE:
PUT /v1/application_key/<APP_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name":"<NEW_APP_KEY_NAME>"
}' \
"https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_EDIT>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"application_key": {
"owner": "john@example.com",
"hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
"name": "<NEW_APP_KEY_NAME>"
}
}
Delete a given application key.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/application_key/<APP_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X DELETE \
-H 'Content-Type: application/json'
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_DELETE>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"application_key": {
"owner": "john@example.com",
"hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
"name": "<APP_KEY_NAME>"
}
}
The Logs endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.
Send your logs to your Datadog platform over HTTP. Limits per HTTP request are:
Any log exceeding 256KB is accepted and truncated by Datadog:
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.comFor Datadog EU: http-intake.logs.datadoghq.eu |
| Path | For API key passed in headers: /v1/inputFor API key passed in path: /v1/input/<DATADOG_API_KEY> |
| Headers | Header to pass the API key: DD-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 |
| Content Encoding | [optional] For compressed content the available content encoding are: gzip and deflate. |
Note: If an API key is passed in both the headers and the path only the one in the headers is taken into account.
SIGNATURE:
https://http-intake.logs.datadoghq.com/v1/input/<DATADOG_API_KEY>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
## Simple Raw Message
## API key passed in headers
curl -X POST https://http-intake.logs.datadoghq.com/v1/input \
-H "Content-Type: text/plain" \
-H "DD-API-KEY: <API_KEY>" \
-d 'hello world'
## API key passed in path
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: text/plain" \
-d 'hello world'
## Log attributes can be passed as query parameters
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY>?ddtags=env:prod,user:my-user \
-H "Content-Type: text/plain" \
-d 'hello world'
## Multi Raw Messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: text/plain" \
--data-binary @- <<BODY
hello
world
BODY
## Simple JSON Message
## Log attributes can also be passed as key:value pairs in valid JSON messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/json" \
-d '{"message":"hello world", "ddsource":"<SOURCE>", "ddtags":"env:<ENV>,user:<USER_NAME>", "hostname":"<HOSTNAME>"}'
## Multi JSON Messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/json" \
--data-binary @- <<BODY
[
{
"message": "hello"
},
{
"message": "world"
}
]
BODY
## Simple Logplex Message
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/logplex-1" \
-d 'hello world'
## Multi Logplex Messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/logplex-1" \
--data-binary @- <<BODY
hello
world
BODY
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}List endpoint returns logs that match a log search query. Results are paginated.
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.
ARGUMENTS:
query [required]:
The search query - following the Log search syntax .time.from [required]:
Minimum timestamp for requested logs. Format can be eithernow -10m, now - 1h, now - 1d)time.to [required]:
Maximum timestamp for requested logs. Format can be eithernow, now -10m, now - 1h, now - 1d)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]:
Hash identifier of the first log to return in the list, available in a log 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]:
Time-ascending asc or time-descending descresults.limit [optional, default=10]:
Number of logs return in the response (maximum is 1000)index [optional, default=main]:
For multi-index organizations, the log index in which the request is performed.SIGNATURE:
POST api/v1/logs-queries/list
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"query": "service:nginx -@http.method:POST",
"time": {
"from": "now - 1h",
"to": "now"
},
"sort": "desc",
"limit": 50
}' \
"https://api.datadoghq.com/api/v1/logs-queries/list"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
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 Index object describes the configuration of a log index. It has the following attributes:
name (Read Only):
The name of the index.filter.query :
Only logs matching the filter criteria are considered for this index.
The search query follows the Log search syntaxnum_retention_days (Read Only) :
The number of days before logs are deleted from this indexdaily_limit (Read Only) :
The number of log-events you can send in this index before you are rate-limited.is_rate_limited (Read Only) :
A boolean stating if the index is rate limited, meaning more logs than the daily limit have been sent. Rate limit is reset every-day at 2pm UTC.exclusion_filters
An array of ExclusionFilter objects (see hereafter). The logs are tested against the query of each ExclusionFilter, following the order of the array. Only the first matching active ExclusionFilter matters, others (if any) are ignored.
name :
The name of the exclusion filteris_enabled :
A boolean stating if the exclusion is active (will eventually exclude logs) or not.filter.query :
Only logs matching the filter criteria AND the query of the parent index will be considered for this exclusion filter.
The search query follows the Log search syntaxfilter.sample_rate :
The fraction of logs excluded by the exclusion filter, when active. The sampling is uniform.Note: You need an API and applications key with Admin right to interact with this endpoint.
This endpoint returns an array of the Index objects of your organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/logs/config/indexes/
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/indexes"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"indexes": [
{
"name": "<INDEX_NAME>",
"filter": {
"query": "<INDEX_FILTER_QUERY>"
},
"num_retention_days": 15,
"daily_limit": 150000000,
"is_rate_limited": false,
"exclusion_filters": [
{
"name": "<INDEX_EXCLUSTION_FILTER_1>",
"is_enabled": true,
"filter": {
"query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
"sample_rate": 1
}
}
]
}
]
}
This endpoint returns an Index identified by its name.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/logs/config/indexes/<INDEX_NAME>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/indexes/<INDEX_NAME>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"name": "<INDEX_NAME>",
"filter": {
"query": "<INDEX_FILTER_QUERY>"
},
"num_retention_days": 15,
"daily_limit": 150000000,
"is_rate_limited": false,
"exclusion_filters": [
{
"name": "<INDEX_EXCLUSTION_FILTER_1>",
"is_enabled": true,
"filter": {
"query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
"sample_rate": 1
}
}
]
}
This endpoint updates an Index identified by its name. It returns the Index object passed in the request body when the request is successful.
ARGUMENTS:
Note: Using the PUT method updates your index’s configuration by replacing your current configuration with the new one sent to your Datadog organization.
filter.query [required]:
Only logs matching the filter criteria will be considered for this index. The search query follows the Log search syntaxexclusion_filters An array of ExclusionFilter objects (see hereafter). The logs are tested against the query of each ExclusionFilter, following the order of the array. Only the first matching active ExclusionFilter matters, others (if any) are ignored. The ExclusionFilter object describes the configuration of an exclusion filter. It has the following attributes:
name [required]:
The name of the exclusion filteris_enabled [optional, default=False]:
A boolean stating if the exclusion is active.filter.query [optional]:
Only logs matching the filter criteria AND the query of the parent index will be considered for this exclusion filter. The search query follows the Log search syntaxfilter.sample_rate [required]:
The fraction of logs excluded by the exclusion filter, when active. The sampling is uniform.SIGNATURE:
PUT /v1/logs/config/indexes/<INDEX_NAME>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"filter": {
"query": "<NEW_INDEX_FILTER_QUERY>"
},
"exclusion_filters": [
{
"name": "<INDEX_EXCLUSTION_FILTER_1>",
"is_enabled": true,
"filter": {
"query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
"sample_rate": 1
}
},
{
"name": "<INDEX_EXCLUSTION_FILTER_2>",
"is_enabled": true,
"filter": {
"query": "<INDEX_EXCLUSTION_FILTER_QUERY_2>",
"sample_rate": 1
}
}
]
}' \
"https://api.datadoghq.com/api/v1/logs/config/indexes/<INDEX_NAME>"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"name": "<INDEX_NAME>",
"filter": {
"query": "<NEW_INDEX_FILTER_QUERY>"
},
"num_retention_days": 15,
"daily_limit": 150000000,
"is_rate_limited": false,
"exclusion_filters": [
{
"name": "<INDEX_EXCLUSTION_FILTER_1>",
"is_enabled": true,
"filter": {
"query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
"sample_rate": 1
}
},
{
"name": "<INDEX_EXCLUSTION_FILTER_2>",
"is_enabled": true,
"filter": {
"query": "<INDEX_EXCLUSTION_FILTER_QUERY_2>",
"sample_rate": 1
}
}
]
}
Use the index order endpoints to control the processing order of an organization’s indexes. Use this endpoint only if you have more than one index for logs in your organization. Note that this index cannot be used to add or delete indexes.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/logs/config/index-order
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/index-order"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"index_names": [
"<INDEX_NAME_1>",
"<INDEX_NAME_2>"
]
}
This endpoint updates the IndexOrder of your organization. It returns the IndexOrder object passed in the request body when the request is successful.
ARGUMENTS:
index_names [required]: Array of Strings identifying by their name(s) the index(es) of your organisation. Logs are tested against the query filter of each index one by one, following the order of the array. Logs are eventually stored in the first matching index.SIGNATURE:
PUT /v1/logs/config/index-order
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"index_names": [
"<INDEX_NAME_2>",
"<INDEX_NAME_1>"
]
}' \
"https://api.datadoghq.com/api/v1/logs/config/index-order"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"index_names": [
"<INDEX_NAME_2>",
"<INDEX_NAME_1>"
]
}
The Logs Pipelines endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support. To set your pipeline permissions see the Granting permissions within limited scopes documentation.
Pipelines and processors operate on incoming logs, parsing and transforming them into structured attributes for easier querying.
Note: These endpoints are only available for admin users. Make sure to use an application key created by an admin.
Get the current order of your pipelines.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/logs/config/pipeline-order
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipeline-order"
EXAMPLE RESPONSE:
Update the order of your pipelines. Since logs are processed sequentially, reordering a pipeline may change the structure and content of the data processed by other pipelines and their processors.
Note: Using the PUT method updates your pipeline order by replacing your current order with the new one sent to your Datadog organization.
ARGUMENTS:
pipeline_ids [required]:
Ordered Array of <PIPELINE_ID> strings, the order of pipeline IDs in the array define the overall Pipelines order for Datadog?SIGNATURE:
PUT /v1/logs/config/pipeline-order
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"pipeline_ids": [
"<PIPELINE_1_ID>",
"<PIPELINE_2_ID>",
"<PIPELINE_3_ID>"
]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipeline-order"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"pipeline_ids": [
"<PIPELINE_1_ID>",
"<PIPELINE_2_ID>",
"<PIPELINE_3_ID>"
]
}
Get all pipelines from your organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/logs/config/pipelines
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipelines"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
[
{
"id": "<PIPELINE_1_ID>",
"type": "pipeline",
"name": "<PIPELINE_1_NAME>",
"is_enabled": false,
"is_read_only": true,
"filter": {
"query": "<PIPELINE_1_FILTER>"
},
"processors": ["<PROCESSOR_PIPELINE_1ARRAY>"
]
},
{
"id": "<PIPELINE_2_ID>",
"type": "pipeline",
"name": "<PIPELINE_2_NAME>",
"is_enabled": false,
"is_read_only": true,
"filter": {
"query": "<PIPELINE_2_FILTER>"
},
"processors": ["<PROCESSOR_PIPELINE_2_ARRAY>"
]
}
]
Get a specific pipeline from your organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/logs/config/pipelines/<PIPELINE_ID>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
pipeline_id=<PIPELINE_ID>
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"id": "<PIPELINE_ID>",
"type": "pipeline",
"name": "<PIPELINE_NAME>",
"is_enabled": false,
"is_read_only": true,
"filter": {
"query": "<PIPELINE_FILTER>"
},
"processors": [
{
"name": "<PROCESSOR_1_NAME>",
"is_enabled": true,
"source": "message",
"grok": {
"support_rules": "",
"match_rules": "<MATCHED_RULES>"
},
"type": "grok-parser"
},
{
"name": "Define timestamp as the official timestamp of the log",
"is_enabled": true,
"sources": [
"timestamp"
],
"type": "date-remapper"
},
{
"name": "Define level as the official log status",
"is_enabled": true,
"sources": [
"level"
],
"type": "status-remapper"
}
]
}
Create a Pipeline in your organization.
ARGUMENTS:
name [required]:
Your pipeline name.
is_enabled [optional, default=False]:
Boolean value to enable your pipeline.
filter.query [optional]: Defines your pipeline filter. Only logs that match the filter criteria are processed by this pipeline.
processors [optional]: Ordered array of processors or nested pipelines. See the Processor documentation to get the specific Scheme for each processor.
SIGNATURE:
POST /v1/logs/config/pipelines
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name": "<PIPELINE_NAME>",
"is_enabled": true,
"filter": {
"query": "<PIPELINE_QUERY>"
},
"processors": [
{
"name": "Define date as the official timestamp of the log",
"is_enabled": true,
"sources": [
"date"
],
"type": "date-remapper"
}
]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipelines"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"id": "7fKHTENgSkyGoJcCDbem-g",
"type": "pipeline",
"name": "<PIPELINE_NAME>",
"is_enabled": true,
"is_read_only": false,
"filter": {
"query": "<PIPELINE_QUERY>"
},
"processors": [
{
"name": "Define date as the official timestamp of the log",
"is_enabled": true,
"sources": [
"date"
],
"type": "date-remapper"
}
]
}
Update a given pipeline configuration to change it’s processors or their order.
ARGUMENTS:
Note: Using the PUT method updates your pipeline configuration by replacing your current configuration with the new one sent to your Datadog organization.
name [required]:
Your pipeline name.
is_enabled [optional, default=False]:
Boolean value to enable your pipeline.
filter.query [optional]: Defines your pipeline filter. Only logs that match the filter criteria are processed by this pipeline.
processors [optional]: Ordered array of processors or nested pipelines. See the Processor documentation to get the specific scheme for each processor.
SIGNATURE:
PUT /v1/logs/config/pipelines/<PIPELINE_ID>
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
pipeline_id=<PIPELINE_ID>
curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"name": "<NEW_PIPELINE_NAME>",
"is_enabled": true,
"filter": {
"query": "<NEW_PIPELINE_QUERY>"
},
"processors": [
{
"name": "Define date as the official timestamp of the log",
"is_enabled": true,
"sources": [
"date"
],
"type": "date-remapper"
}
]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"id": "<PIPELINE_ID>",
"type": "pipeline",
"name": "<NEW_PIPELINE_NAME>",
"is_enabled": true,
"is_read_only": false,
"filter": {
"query": "<NEW_PIPELINE_QUERY>"
},
"processors": [
{
"name": "Define date as the official timestamp of the log",
"is_enabled": true,
"sources": [
"date"
],
"type": "date-remapper"
}
]
}
Delete a given pipeline from your Organization.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
DELETE /v1/logs/config/pipelines
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
pipeline_id=<PIPELINE_ID>
curl -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}"
EXAMPLE RESPONSE:
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}The metrics endpoint allows you to:
Note that a graph can only contain a set number of points, and as the timeframe over which a metric is viewed increases, aggregation between points occurs to stay below that set number.
Datadog has a soft limit of 100 timeseries per host, where a timeseries is defined as a unique combination of metric name and tag.
This endpoint is not supported in Datadog’s Ruby client library. To request this functionality, contact Datadog Support.
Get the list of actively reporting metrics from a given time until now. This endpoint is not available in the Python and Ruby libraries.
ARGUMENTS:
from [required]:
Seconds since the Unix epochhost [optional]:
Hostname for filtering the list of metrics returned. If set, metrics retrieved are those with the corresponding hostname tag.SIGNATURE:
GET /v1/metrics
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
# Taking the last 24hours
from_time = int(time.time()) - 60 * 60 * 24 * 1
result = api.Metric.list(from_time)
print(result)
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
from_time=$((date +%s - 86400))
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/metrics?from=${from_time}&host=<HOSTNAME>"
EXAMPLE RESPONSE:
{
"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. The limit for compressed payloads is 3.2 megabytes (3200000), and 62 megabytes (62914560) for decompressed payloads.
Overhead:
If you’re submitting metrics directly to the Datadog API without using DogStatsD, expect:
The full payload is approximately ~ 100 bytes. However, with the DogStatsD API, compression is applied, which reduces the payload size.
ARGUMENTS:
series [required]:
Pass a JSON array where each item in the array contains the following arguments:
metric [required]:
The name of the timeseriestype [optional, default=gauge]:
Type of your metric either: gauge, rate, or countinterval [optional, default=None]:
If the type of the metric is rate or count, define the corresponding interval.points [required]:
A JSON array of points. Each point is of the form:
[[POSIX_timestamp, numeric_value], ...]
Note: The timestamp should be in seconds, current. The numeric value format should be a float value.
Current is defined as not more than 10 minutes in the future or more than 1 hour in the past.host [optional]:
The name of the host that produced the metric.tags [optional, default=None]:
A list of tags associated with the metric.SIGNATURE:
POST /v1/series
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>'
}
initialize(**options)
now = time.time()
future_10s = now + 10
# Submit a single point with a timestamp of `now`
api.Metric.send(metric='page.views', points=1000)
# Submit a point with a timestamp (must be ~current)
api.Metric.send(metric='my.pair', points=(now, 15))
# Submit multiple points.
api.Metric.send(
metric='my.series',
points=[
(now, 15),
(future_10s, 16)
]
)
# Submit a point with a host and tags.
api.Metric.send(
metric='my.series',
points=100,
host="myhost.example.com",
tags=["version:1"]
)
# Submit multiple metrics
api.Metric.send([{
'metric': 'my.series',
'points': 15
}, {
'metric': 'my1.series',
'points': 16
}])
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
dog = Dogapi::Client.new(api_key)
# Submit one metric value.
dog.emit_point('some.metric.name', 50.0, :host => "my_host.example.com")
# Submit multiple metric values
points = [
[Time.now, 0],
[Time.now + 10, 10.0],
[Time.now + 20, 20.0]
]
dog.emit_points('some.metric.name', points, :tags => ["version:1"])
# Emit differents metrics in a single request to be more efficient
dog.batch_metrics do
dog.emit_point('test.api.test_metric',10)
dog.emit_point('test.api.this_other_metric', 1)
end
currenttime=$(date +%s)
curl -X POST -H "Content-type: application/json" \
-d "{ \"series\" :
[{\"metric\":\"test.metric\",
\"points\":[[$currenttime, 20]],
\"type\":\"rate\",
\"interval\": 20,
\"host\":\"test.example.com\",
\"tags\":[\"environment:test\"]}
]
}" \
"https://api.datadoghq.com/api/v1/series?api_key="<DATADOG_API_KEY>""
This endpoint allows you to query for metrics from any time period. Use the query syntax described in From the query to the graph.
Note: In Python, from is a reserved word. So instead, the Python API uses the start and end parameters in the function call.
ARGUMENTS:
from [required except in Python]:
Seconds from the unix epochto [required except in Python]:
Seconds to the unix epochstart [required in Python, default=None]:
Seconds since the unix epochend [required in Python, default=None]:
Seconds since the unix epochquery [required]:
The query stringSIGNATURE:
GET /v1/query
EXAMPLE REQUEST:
from datadog import initialize, api
import time
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
now = int(time.time())
query = 'system.cpu.idle{*}by{host}'
print(api.Metric.query(start=now - 3600, end=now, query=query))
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get points from the last hour
from = Time.now - 3600
to = Time.now
query = 'system.cpu.idle{*}by{host}'
dog.get_points(query, from, to)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
to_time=$(date +%s)
from_time=$(date --date='1 day ago' +%s)
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/query?&query=avg:system.cpu.user\{*\}by\{host\}&from=${from_time}&to=${to_time}"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
This endpoint takes no JSON arguments.
SIGNATURE:
GET /v1/metrics/<METRIC_NAME>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
metric = 'system.cpu.idle'
api.Metadata.get(metric_name=metric)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get metadata on metric
result = dog.get_metadata('system.net.bytes_sent')
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
metric_name="system.net.bytes_sent"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/metrics/${metric_name}"
EXAMPLE RESPONSE:
{
'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
ARGUMENTS:
type [required]:
Metric type such as gauge or ratedescription [optional, default=None]:
String description of the metric” defaultshort_name [required]:
Short name string of the metricunit [optional, default=None]:
Primary unit of the metric such as byte or operationper_unit [optional, default=None]:
Per unit of the metric such as second in bytes per secondstatsd_interval [optional, default=None]:
If applicable, statds flush interval in seconds for the metricSIGNATURE:
PUT /v1/metrics/<METRIC_NAME>
EXAMPLE REQUEST:
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
metric = 'system.net.bytes_sent'
params = {
'description': 'My custom description',
'short_name': 'bytes sent',
'type': 'gauge',
'unit': 'byte',
'per_unit': 'second'
}
api.Metadata.update(metric_name=metric, **params)
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
updates = {
"type" => "gauge",
"description" => "my custom description",
"short_name" => "bytes sent",
"unit" => "byte",
"per_unit" => "second"
}
# Submit updates for metric
result = dog.update_metadata('system.net.bytes_sent', updates)api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
metric_name="system.net.bytes_sent"
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"type": "gauge",
"description": "my custom description",
"short_name": "bytes sent",
"unit": "byte",
"per_unit": "second"
}' \
"https://api.datadoghq.com/api/v1/metrics/${metric_name}"
EXAMPLE RESPONSE:
{
'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 endpoint allows you to search for metrics from the last 24 hours in Datadog.
ARGUMENTS:
q [required]:
The query string to search metrics upon.
Must be prefixed with metrics:Note: The prefix host: is also supported for the query to seach over host names, but it is deprecated, use the host search endpoint instead.
SIGNATURE:
GET /v1/search
EXAMPLE REQUEST:
# This is not yet supported by the Python Client for the Datadog API
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.search("metrics:test")
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/search?q=metrics:aws"
EXAMPLE RESPONSE:
{
'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.
ARGUMENTS:
type [required]:
The type of the monitor, chosen from:| 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 or service check |
| live process | process alert |
| logs | log alert |
| metric | metric alert |
| network | service check |
| outlier | query alert |
| process | service check |
| rum | rum alert |
| watchdog | event alert |
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. It is limited to 100.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).status 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 thresholdlogs(query).index(index_name).rollup(rollup_method[, measure]).last(time_window) operator #
query The search query - following the Log search syntax .index_name For multi-index organizations, the log index in which the request is performed.rollup_method The stats rollup method - supports count, avg and cardinality.measure For avg and cardinality rollup_method - specify the measure or the facet name you want to use.time_window #m (5, 10, 15, or 30), #h (1, 2, or 4, 24)operator <, <=, >, >=, ==, or !=.# an integer or decimal number used to set the threshold.12345 && 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