API Reference

Overview

This section details Datadog's HTTP API. It makes it easy to get data in and out of Datadog. The Datadog API uses resource-oriented URLs, uses status codes to indicate the success or failure of requests and returns JSON from all requests. Let's dive in and see how it works.
Libraries
There are many client libraries that wrap the Datadog API. Check them out.
API Endpoint
https://app.datadoghq.com/api/

Authentication

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

You can manage your account's API and application keys here.

Example
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

curl "https://app.datadoghq.com/api/v1/validate?api_key=9775a026f1ca7d1c6c5af9d94d9595a4"

# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

dog = Dogapi::Client.new('9775a026f1ca7d1c6c5af9d94d9595a4', '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff')

Success and Errors

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.

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 will indicate success and the response body will contain the expected result with the addition of a warnings array containing detailed warning messages.

Status Codes
  • 200 OK
  • 201 Created
  • 202 Accepted
  • 204 No Content
  • 301 Moved Permanently
  • 304 Not Modified
  • 401 Unauthorized
  • 403 Forbidden
  • 404 Not Found
  • 409 Conflict
  • 422 Unprocessable Entity
  • 500 Server Error
Example 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.'
  ]
}

Metrics

The metrics end-point allows you to:

  • Post metrics data so it can be graphed on Datadog's dashboards
  • Query metrics from any time period

As occurs within the Datadog UI, a graph can only contain a set number of points and as the timeframe over which a metric is viewed increases, aggregation between points will occur to stay below that set number.

Thus, if you are querying for larger timeframes of data, the points returned will be more aggregated. The max granularity within Datadog is one point per second, so if you had submitted points at that interval and requested a very small interval from the query API (in this case, probably less than 100 seconds), you could end up getting all of those points back. Otherwise, our algorithm tries to return about 150 points per any given time window, so you'll see coarser and coarser granularity as the amount of time requested increases. We do this time aggregation via averages.

Post time series points

The metrics end-point allows you to post time-series data that can be graphed on Datadog's dashboards.

Arguments
  • series [required]
    A JSON array of metrics of the form. Each metric is of the form:
    • metric [required]
      The name of the time series
    • points [required]
      A JSON array of points. Each point is of the form:
      [[POSIX_timestamp, numeric_value], ...]
      Note that the timestamp must be current.
    • host [optional, default=None]
      The name of the host that produced the metric.
    • tags [optional, default=None]
      A list of tags associated with the metric.
    • type [optional, default=gauge]
      The type of the metric - gauge or counter (counter data is expected as a rate). Gauges are 32bit floats while counters are 64bit integers.
Signature
POST https://app.datadoghq.com/api/v1/series
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api
import time

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

CurrentPosixTime = time.time()
CurrentPosixTime10 = time.time() + 10

initialize(**options)

# 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=(CurrentPosixTime, 15))

# Submit multiple points.
api.Metric.send(metric='my.series', points=[(CurrentPosixTime, 15), (CurrentPosixTime10, 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}])
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account


currenttime=$(date +%s)
curl  -X POST -H "Content-type: application/json" \
-d "{ \"series\" :
         [{\"metric\":\"test.metric\",
          \"points\":[[$currenttime, 20]],
          \"type\":\"gauge\",
          \"host\":\"test.example.com\",
          \"tags\":[\"environment:test\"]}
        ]
    }" \
'https://app.datadoghq.com/api/v1/series?api_key=9775a026f1ca7d1c6c5af9d94d9595a4'
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key = "abcdef123456"

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

Query time series points

This end point allows you to query for metrics from any time period.

Arguments
  • start [required]
    seconds since the unix epoch
  • end [required]
    seconds since the unix epoch
  • query [required]
    The query string
Query Language

Any query used for a graph can be used here. See here for more details. The time between from and to should be less than 24 hours. If it is longer, you will receive points with less granularity.

Signature
GET https://app.datadoghq.com/api/v1/query
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

#!/usr/bin/python
from datadog import initialize, api
import time

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

start = int(time.time()) - 3600
end = start + 3600
# query for idle CPU for all machines tagged with speed:4000
query = 'system.cpu.idle{*}by{host}'

results = api.Metric.query(start=start - 3600, end=end, query=query)
print results
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
to_time=$(date +%s)
from_time=$(date -v -1d +%s)

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

Events

The events service allows you to programatically post events to the stream and fetch events from the stream.

Post an Event

This end point allows you to post events to the stream. You can tag them, set priority and event aggregate them with other events.

Arguments
  • title [required]
    The event title. Limited to 100 characters.
  • text [required]
    The body of the event. Limited to 4000 characters. The text supports markdown.
  • date_happened [optional, default=now]
    POSIX timestamp of the event.
  • priority [optional, default='normal']
    The priority of the event ('normal' or 'low').
  • host [optional, default=None]
    Host name to associate with the event.
  • tags [optional, default=None]
    A list of tags to apply to the event.
  • alert_type [optional, default='info']
    "error", "warning", "info" or "success".
  • aggregation_key [optional, default=None]
    An arbitrary string to use for aggregation, max length of 100 characters.
  • source_type_name [optional, default=None]
    The type of event being posted.
    Options: nagios, hudson, jenkins, user, my apps, feed, chef, puppet, git, bitbucket, fabric, capistrano
Signature
POST /api/v1/events
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

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.
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

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://app.datadoghq.com/api/v1/events?api_key=9775a026f1ca7d1c6c5af9d94d9595a4'
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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.
Example Response
{'event': {'date_happened': 1419436860,
  'handle': None,
  'id': 2603387619536318140,
  'priority': None,
  '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'}
{
    "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"
}
["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}}]

Get an Event

This end point allows you to query for event details.

Arguments
This end point takes no JSON arguments.
Signature
GET /api/v1/events/:event_id
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

api.Event.get(2603387619536318140)
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
event_id=1377281704830403917

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

curl "https://app.datadoghq.com/api/v1/events/${event_id}?api_key=${api_key}&application_key=${app_key}"
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

event_id = '1375909614428331251'
dog.get_event(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'}}
{
    "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"
    }
}
["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"=>"{}"}}]

Query the Event Stream

The event stream can be queried and filtered by time, priority, sources and tags.

Arguments
  • start [required]
    POSIX timestamp
  • end [required]
    POSIX timestamp
  • priority [optional, default=None]
    'low' or 'normal'
  • sources [optional, default=None]
    A comma separated string of sources
  • tags [optional, default=None]
    A comma separated string of tags
Signature
GET /api/v1/events
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api
import time

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)


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

api.Event.query(start=start_time, end=end_time, priority="normal", tags=["application:web"])
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

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

dog.stream(start_time, end_time, :priority=>"normal", :tags=>["application:web"])
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

# Note: this end point only accepts form-encoded requests.
currenttime=$(date +%s)
currenttime2=$(date --date='1 day ago' +%s)
curl -G -H "Content-type: application/json" \
    -d "start=${currenttime2}" \
    -d "end=${currenttime}" \
    -d "api_key=9775a026f1ca7d1c6c5af9d94d9595a4" \
    -d "application_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff" \
    'https://app.datadoghq.com/api/v1/events'
Example Response
[{'alert_type': 'info',
  'comments': [],
  'date_happened': 1419436860,
  'device_name': None,
  'host': None,
  'id': 2603387619536318140,
  'is_aggregate': False,
  'priority': 'normal',
  'resource': '/api/v1/events/2603387619536318140',
  '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=2603387619536318140'},
  {'alert_type': 'info',
  'comments': [],
  'date_happened': 1419436865,
  'device_name': None,
  'host': None,
  'id': 2603387619536318141,
  'is_aggregate': False,
  'priority': 'normal',
  'resource': '/api/v1/events/2603387619536318141',
  '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=2603387619536318141'}]
["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"
        }
    ]
}

Service Checks

The service check endpoint allows you to post check statuses for use with monitors.

Post a Check Run

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.
    Options: '0': OK, '1': WARNING, '2': CRITICAL, '3': UNKNOWN
  • timestamp [optional, default=now]
    POSIX timestamp of the event.
  • message [optional, default=None]
    A description of why this status occurred
  • tags [optional, default=None]
    A list of key:val tags for this check
Signature
POST /api/v1/check_run
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

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

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

check = 'app.ok'
host = 'app1'
status = CheckStatus.OK

api.ServiceCheck.check(check=check, host_name=host, status=status, message='Response: 200 OK')
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

currenttime=$(date +%s)
curl  -X POST -H "Content-type: application/json" \
-d "{
      \"check\": \"app.is_ok\",
      \"host_name\": \"app1\",
      \"timestamp\": $currenttime,
      \"status\": 0
  }" \
'https://app.datadoghq.com/api/v1/check_run?api_key=9775a026f1ca7d1c6c5af9d94d9595a4'
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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.service_check('app.is_ok', 'app1', 0, :message => 'Response: 200 OK')
Example Response
{'status': 'ok'}
{
    "status": "ok"
}
["202", {"status"=>"ok"}]

Monitors

Monitors allow you to watch a metric or check that you care about, notifying your team when some defined threshold is exceeded. Please refer to the Guide to Monitoring for more information on creating monitors.

Create a monitor

Arguments
  • type [required]
    The type of the monitor, chosen from:
    • metric alert
    • service check
  • query [required]
    The monitor query to notify on with syntax varying depending on what type of monitor you are creating.
    Metric Alert Query
    time_aggr(time_window):space_aggr:metric{tags} [by {key}] operator #
    • time_aggr avg, sum, max, min, change, or pct_change
    • time_window last_#m (5, 10, 15, or 30), last_#h (1, 2, or 4), or last_1d
    • space_aggr avg, sum, min, or max
    • tags 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 threshold
    If you are using the change or pct_change time aggregator, you can instead use change_aggr(time_aggr(time_window), timeshift):space_aggr:metric{tags} [by {key}] operator # with:
    • change_aggr change, pct_change
    • time_aggr avg, sum, max, min
    • time_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_ago
    Service Check Query
    "check".over(tags).last(count).count_by_status()
    • check name of the check, e.g. datadog.agent.up
    • tags 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.
  • name [optional, default=dynamic, based on query]
    The name of the alert.
  • message [optional, default=dynamic, based on query]
    A message to include with notifications for this monitor. Email notifications can be sent to specific users by using the same '@username' notation as events.
  • tags [optional, default=empty list]
    A list of tags to associate with your monitor. This can help you categorize and filter monitors.
  • options [optional]
    A dictionary of options for the monitor. There are options that are common to all types as well as options that are specific to certain monitor types.
    Common Options
    • silenced dictionary of scopes to timestamps or None. Each scope will be muted until the given POSIX timestamp or forever if the value is None.

      Default: None

      Examples:

      • To mute the alert completely:

        {'*': None}

      • To mute role:db for a short time:

        {'role:db': 1412798116}

    • notify_no_data a boolean indicating whether this monitor will notify when data stops reporting.

      Default: false

    • no_data_timeframe the number of minutes before a monitor will notify when data stops reporting. Must be at least 2x the monitor timeframe for metric alerts or 2 minutes for service checks.

      Default: 2x timeframe for metric alerts, 2 minutes for service checks

    • timeout_h the number of hours of the monitor not reporting data before it will automatically resolve from a triggered state.

      Default: None

    • renotify_interval the number of minutes after the last notification before a monitor will re-notify on the current status. It will only re-notify if it's not resolved.

      Default: None

    • escalation_message a message to include with a re-notification. Supports the '@username' notification we allow elsewhere. Not applicable if renotify_interval is None.

      Default: None

    • notify_audit a boolean indicating whether tagged users will be notified on changes to this monitor.

      Default: False

    Service Check Options
    These options only apply to service checks and will be ignored for other monitor types.
    • thresholds a dictionary of thresholds by status. Because service checks can have multiple thresholds, we don't define them directly in the query.

      Default: {'ok': 1, 'critical': 1, 'warning': 1}

Signature
POST /api/v1/monitor
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Create a new monitor
options = {
    "notify_no_data": True,
    "no_data_timeframe": 20
}
tags = ["app:webserver", "frontend"]
api.Monitor.create(type="metric alert", query="avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100", name="Bytes received on host0", message="We may need to add web hosts if this is consistently high.", tags=tags, options=options)
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Create a new monitor
options = {
  'notify_no_data' => true,
  'no_data_timeframe' => 20
}
tags = ['app:webserver', 'frontend']
dog.monitor("metric alert", "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100", :name => "Bytes received on host0", :message => "We may need to add web hosts if this is consistently high.", :tags => tags, :options => options)
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
alert_id=512

curl -X POST -H "Content-type: application/json" \
-d '{
      "type": "metric alert",
      "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high.",
      "tags": ["app:webserver", "frontend"],
      "options": {
      	"notify_no_data": true,
      	"no_data_timeframe": 20
      }
    }' \
    "https://app.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}"
Example Response
{'creator': {'email': 'matt@example.com',
  'handle': 'matt@example.com',
  'id': 1896,
  'name': u'Matt'},
 'id': 2081,
 'message': 'We may need to add web hosts if this is consistently high.',
 'name': 'Bytes received on host0',
 'tags': ['app:webserver', 'frontend'],
 'options': {'no_data_timeframe': 20,
  'notify_audit': False,
  'notify_no_data': True,
  'silenced': {}},
 'org_id': 2,
 'overall_state': 'No Data',
 'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
 'type': 'metric alert',
 'multi': False}
["200",
 {"name"=>"Bytes received on host0",
  "org_id"=>1499,
  "tags"=>["app:webserver", "frontend"],
  "options"=>
   {"notify_no_data"=>true,
    "no_data_timeframe"=>20,
    "notify_audit"=>false,
    "silenced"=>{}},
  "state"=>{},
  "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
  "message"=>"We may need to add web hosts if this is consistently high.",
  "type"=>"metric alert",
  "id"=>92089,
  "multi"=>false}]
{
    "id": 92090,
    "message": "We may need to add web hosts if this is consistently high.",
    "name": "Bytes received on host0",
    "tags": ["app:webserver", "frontend"],
    "options": {
        "no_data_timeframe": 20,
        "notify_audit": false,
        "notify_no_data": true,
        "silenced": {}
    },
    "org_id": 1499,
    "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
    "state": {},
    "type": "metric alert",
    "multi": false
}

Get a monitor's details

Arguments
  • group_states [optional, default=None]
    A comma-separated string indicating what, if any, group states to include. Choose from one or more from 'all', 'alert', 'warn', or 'no data'. Example: 'alert,warn'
Signature
GET /api/v1/monitor/:monitor_id
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Get a monitor's details
api.Monitor.get(2081)
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Get a monitors's details
dog.get_monitor(91879)
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
monitor_id=91879

# Create a monitor to show
monitor_id=$(curl -X POST -H "Content-type: application/json" \
-d '{
      "type": "metric alert",
      "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high."
    }' \
    "https://app.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}" | jq '.id')

curl -G "https://app.datadoghq.com/api/v1/monitor/${monitor_id}" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}"
Example Response
{'id': 2081,
 'message': 'We may need to add web hosts if this is consistently high.',
 'name': 'Bytes received on host0',
 'options': {'no_data_timeframe': 20,
  'notify_audit': False,
  'notify_no_data': True,
  'silenced': {}},
 'org_id': 2,
 'overall_state': 'No Data',
 'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
 'type': 'metric alert',
 'multi': False}
["200",
 {"name"=>"Bytes received on host0",
  "org_id"=>1499,
  "options"=>{"notify_no_data"=>false, "notify_audit"=>false, "silenced"=>{}},
  "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
  "message"=>"We may need to add web hosts if this is consistently high.",
  "type"=>"metric alert",
  "id"=>91879,
  "multi"=>false}]
{
    "id": 91879,
    "message": "We may need to add web hosts if this is consistently high.",
    "name": "Bytes received on host0",
    "options": {
        "notify_audit": false,
        "notify_no_data": false,
        "silenced": {}
    },
    "org_id": 1499,
    "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
    "type": "metric alert",
    "multi": false
}

Edit a monitor

Arguments
  • query [required]
    The metric query to alert on.
  • name [optional, default=dynamic, based on query]
    The name of the monitor.
  • message [optional, default=dynamic, based on query]
    A message to include with notifications for this monitor. Email notifications can be sent to specific users by using the same '@username' notation as events.
  • options [optional, default=None]
    Refer to the create monitor documentation for details on the available options.
  • tags [optional, default=empty list]
    A list of tags to associate with your monitor. This can help you categorize and filter monitors.
Signature
PUT /api/v1/monitor/:monitor_id
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize,  api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Edit an existing monitor
api.Monitor.update(2081, query="avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100", name="Bytes received on host0", message="We may need to add web hosts if this is consistently high.")
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Edit an existing monitor
dog.update_monitor(91879, "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100", :message => "Bytes received on host0", :name => "We may need to add web hosts if this is consistently high.")
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
monitor_id=91879

# Create a monitor to edit
monitor_id=$(curl -X POST -H "Content-type: application/json" \
-d '{
      "type": "metric alert",
      "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high."
    }' \
    "https://app.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}" | jq '.id')

curl -X PUT -H "Content-type: application/json" \
-d '{
      "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high."
    }' \
    "https://app.datadoghq.com/api/v1/monitor/${monitor_id}?api_key=${api_key}&application_key=${app_key}"
Example Response
{'id': 2081,
 'message': 'We may need to add web hosts if this is consistently high.',
 'name': 'Bytes received on host0',
 'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
 'org_id': 2,
 'overall_state': 'No Data',
 'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
 'type': 'metric alert',
 'multi': False}
["200",
 {"name"=>"We may need to add web hosts if this is consistently high.",
  "org_id"=>1499,
  "options"=>{"notify_no_data"=>false, "notify_audit"=>false, "silenced"=>{}},
  "state"=>{},
  "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
  "message"=>"Bytes received on host0",
  "type"=>"metric alert",
  "id"=>91879,
  "multi"=>false}]
{
    "id": 91879,
    "message": "We may need to add web hosts if this is consistently high.",
    "name": "Bytes received on host0",
    "options": {
        "notify_audit": false,
        "notify_no_data": false,
        "silenced": {}
    },
    "org_id": 1499,
    "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
    "state": {},
    "type": "metric alert",
    "multi": false
}

Delete a monitor

Arguments
This end point takes no JSON arguments.
Signature
DELETE /api/v1/monitor/:monitor_id
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Delete a monitor
api.Monitor.delete(2081)
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Delete a monitor
dog.delete_monitor(62625)
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
monitor_id=59409

# Create a monitor to delete
monitor_id=$(curl -X POST -H "Content-type: application/json" \
-d '{
      "type": "metric alert",
      "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high."
    }' \
    "https://app.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}" | jq '.id')

curl -X DELETE "https://app.datadoghq.com/api/v1/monitor/${monitor_id}?api_key=${api_key}&application_key=${app_key}"
Example Response
{'deleted_monitor_id': 2081}
["200", {"deleted_monitor_id"=>62625}]
{
    "deleted_monitor_id": 59409
}

Get all monitor details

Arguments
  • group_states [optional, default=None]
    A string list indicating what, if any, group states to include. Choose from one or more from 'all', 'alert', 'warn', or 'no data'. Example: 'alert,warn'
  • tags [optional, default=None]
    A comma separated list indicating what tags, if any, should be used to filter the list of monitors by scope
Signature
GET /api/v1/monitor
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Get all monitor details
print api.Monitor.get_all()
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Get all monitor details
dog.get_all_monitors()
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff

curl -G "https://app.datadoghq.com/api/v1/monitor" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}"
Example Response
[ {'creator': {'email': 'matt@example.com',
   'handle': 'matt@example.com',
   'id': 1896,
   'name': u'Matt'},
  'id': 2085,
  'message': u'',
  'name': '**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.',
  'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
  'org_id': 2,
  'overall_state': 'No Data',
  'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
  'type': 'metric alert',
  'multi': False},
 {'creator': {'email': 'matt@example.com',
   'handle': 'matt@example.com',
   'id': 1896,
   'name': u'Matt'},
  'id': 2083,
  'message': 'We may need to add web hosts if this is consistently high.',
  'name': 'Bytes received on host0',
  'options': {'no_data_timeframe': 20,
   'notify_audit': False,
   'notify_no_data': True,
   'silenced': {}},
  'org_id': 2,
  'overall_state': 'No Data',
  'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
  'type': 'metric alert',
  'multi': False}]
["200",
 [{"name"=>"Bytes received on host0",
   "org_id"=>1499,
   "options"=>{"notify_no_data"=>false, "notify_audit"=>false, "silenced"=>{}},
   "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
   "message"=>"We may need to add web hosts if this is consistently high.",
   "type"=>"metric alert",
   "multi"=>false,
   "id"=>91879},
  {"name"=>
    "**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.",
   "org_id"=>1499,
   "options"=>
    {"notify_audit"=>true,
     "timeout_h"=>nil,
     "silenced"=>{},
     "no_data_timeframe"=>false,
     "notify_no_data"=>false,
     "renotify_interval"=>nil,
     "escalation_message"=>""},
   "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
   "message"=>"",
   "type"=>"metric alert",
   "multi"=>false,
   "id"=>91875}]]
[
    {
        "id": 91879,
        "message": "We may need to add web hosts if this is consistently high.",
        "name": "Bytes received on host0",
        "options": {
            "notify_audit": false,
            "notify_no_data": false,
            "silenced": {}
        },
        "org_id": 1499,
        "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
        "type": "metric alert",
        "multi": false
    },
    {
        "id": 91875,
        "message": "",
        "name": "**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.",
        "options": {
            "escalation_message": "",
            "no_data_timeframe": false,
            "notify_audit": true,
            "notify_no_data": false,
            "renotify_interval": null,
            "silenced": {},
            "timeout_h": null
        },
        "org_id": 1499,
        "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
        "type": "metric alert",
        "multi": false
    }
]

Mute all monitors

Muting will prevent all monitors from notifying through email and posts to the event stream. State changes will only be visible by checking the alert page.

Arguments
This end point takes no JSON arguments.
Signature
POST /api/v1/monitor/mute_all
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Mute all monitors
api.Monitor.mute_all()
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Mute all alerts
dog.mute_monitors()
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff

curl -X POST "https://app.datadoghq.com/api/v1/monitor/mute_all?api_key=${api_key}&application_key=${app_key}"
Example Response
{'active': True,
 'disabled': False,
 'end': None,
 'id': 2728,
 'message': None,
 'scope': ['*'],
 'start': 1419440110}
["200",
 {"end"=>nil,
  "disabled"=>false,
  "start"=>1412805855,
  "active"=>true,
  "scope"=>["*"],
  "id"=>1647}]
{
    "active": true,
    "disabled": false,
    "end": null,
    "id": 1648,
    "scope": [
        "*"
    ],
    "start": 1412805856
}

Unmute all monitors

Disables muting all monitors. Throws an error if mute all was not enabled previously.

Arguments
This end point takes no JSON arguments.
Signature
POST /api/v1/monitor/unmute_all
Example Request
# Make sure you replace the API and or APP key below with the ones for your account

from datadog import initialize, api

options = {
    'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
    'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
}

initialize(**options)

# Unmute all alerts
api.Monitor.unmute_all()
# Make sure you replace the API and or APP key below with the ones for your account

require 'rubygems'
require 'dogapi'

api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'

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

# Unmute all alerts
dog.unmute_monitors()
#!/bin/sh
# Make sure you replace the API and or APP key below with the ones for your account

api_key=9775a026f1ca7d1c6c5af9d94d9595a4
app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff

curl -X POST "https://app.datadoghq.com/api/v1/monitor/unmute_all?api_key=${api_key}&application_key=${app_key}"
Example Response
This end point does not return JSON on successful requests.

Mute a monitor

Arguments
  • scope [optional, default=None]
    The scope to apply the mute to, e.g. role:db
  • end [optional, default=None]
    A POSIX timestamp for when the mute should end
  • Signature
    POST /api/v1/monitor/:monitor_id/mute
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Mute a monitor
    api.Monitor.mute(2088)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Mute a monitor
    dog.mute_monitor(62628)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    monitor_id=62628
    
    # Create a monitor to mute
    monitor_id=$(curl -X POST -H "Content-type: application/json" \
    -d '{
          "type": "metric alert",
          "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
          "name": "Bytes received on host0",
          "message": "We may need to add web hosts if this is consistently high."
        }' \
        "https://app.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    
    curl -X POST "https://app.datadoghq.com/api/v1/monitor/${monitor_id}/mute?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'id': 2088,
     'message': 'We may need to add web hosts if this is consistently high.',
     'name': 'Bytes received on host0',
     'options': {'notify_audit': False,
      'notify_no_data': False,
      'silenced': {'*': None}},
     'org_id': 2,
     'overall_state': 'No Data',
     'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
     'type': 'metric alert'}
    ["200",
     {"name"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
      "org_id"=>1499,
      "options"=>
       {"notify_no_data"=>false,
        "notify_audit"=>true,
        "timeout_h"=>nil,
        "silenced"=>{"*"=>nil},
        "is_data_sparse"=>false,
        "renotify_interval"=>nil},
      "state"=>{},
      "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
      "message"=>"",
      "type"=>"metric alert",
      "id"=>62628}]
    {
        "id": 62628,
        "message": "",
        "name": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "options": {
            "is_data_sparse": false,
            "notify_audit": true,
            "notify_no_data": false,
            "renotify_interval": null,
            "silenced": {
                "*": null
            },
            "timeout_h": null
        },
        "org_id": 1499,
        "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "state": {},
        "type": "metric alert"
    }
    

    Unmute a monitor

    Arguments
  • scope [optional, default=None]
    The scope to apply the mute to. For example, if your alert is grouped by {host}, you might mute 'host:app1'
  • all_scopes [optional, default=False]
    Clear muting across all scopes
  • Signature
    POST /api/v1/monitor/:monitor_id/unmute
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Unmute all alerts
    api.Monitor.unmute(2088)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Unmute all alerts
    dog.unmute_monitor(62628)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    monitor_id=62628
    
    # Create a monitor to unmute
    monitor_id=$(curl -X POST -H "Content-type: application/json" \
    -d '{
          "type": "metric alert",
          "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
          "name": "Bytes received on host0",
          "message": "We may need to add web hosts if this is consistently high."
        }' \
        "https://app.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    curl -X POST "https://app.datadoghq.com/api/v1/monitor/${monitor_id}/mute?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'id': 2088,
     'message': 'We may need to add web hosts if this is consistently high.',
     'name': 'Bytes received on host0',
     'options': {'notify_audit': False,
      'notify_no_data': False,
      'silenced': {}},
     'org_id': 2,
     'overall_state': 'No Data',
     'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
     'type': 'metric alert'}
    ["200",
     {"name"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
      "org_id"=>1499,
      "options"=>
       {"notify_no_data"=>false,
        "notify_audit"=>true,
        "timeout_h"=>nil,
        "silenced"=>{},
        "is_data_sparse"=>false,
        "renotify_interval"=>nil},
      "state"=>{},
      "query"=>"avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
      "message"=>"",
      "type"=>"metric alert",
      "id"=>62628}]
    {
        "id": 62628,
        "message": "",
        "name": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "options": {
            "is_data_sparse": false,
            "notify_audit": true,
            "notify_no_data": false,
            "renotify_interval": null,
            "silenced": {
                "*": null
            },
            "timeout_h": null
        },
        "org_id": 1499,
        "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "state": {},
        "type": "metric alert"
    }
    

    Downtimes

    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.

    Schedule monitor downtime

    Arguments
  • scope [required]
    The scope to apply the downtime to, e.g. 'host:app2'
  • start [optional, default=None]
    POSIX timestamp to start the downtime. In the default case, the downtime will start immediately.
  • end [optional, default=None]
    POSIX timestamp to end the downtime. In the default case, the downtime will go until cancelled.
  • 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 events
  • Signature
    POST /api/v1/downtime
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    import time
    
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Schedule downtime
    api.Downtime.create(scope='env:staging', start=int(time.time()))
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Schedule downtime
    dog.schedule_downtime('env:testing', :start => Time.now.to_i)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    currenttime=$(date +%s)
    
    curl -X POST -H "Content-type: application/json" \
    -d "{
          \"scope\": \"env:prod\",
          \"start\": \"${currenttime}\"
        }" \
        "https://app.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'active': False,
     'disabled': False,
     'end': None,
     'id': 2910,
     'message': None,
     'scope': ['env:staging'],
     'start': 1420387032}
    ["200",
     {"end"=>nil,
      "disabled"=>false,
      "start"=>1412859237,
      "active"=>false,
      "scope"=>["env:testing"],
      "id"=>1674}]
    {
        "active": false,
        "disabled": false,
        "end": null,
        "id": 1656,
        "scope": [
            "env:prod"
        ],
        "start": 1412809696
    }
    

    Update monitor downtime

    Arguments
  • id [required]
    The integer id of the downtime to be updated
  • scope [optional, default=original scope]
    The scope to apply the downtime to, e.g. 'host:app2'
  • start [optional, default=original start]
    POSIX timestamp to start the downtime
  • end [optional, default=original end]
    POSIX timestamp to end the downtime, or None if the downtime should continue until cancelled
  • message [optional, 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 events
  • Signature
    PUT /api/v1/downtime/:downtime_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    import time
    
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    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.")
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Update downtime
    stagingDowntimes = []
    downtimes = dog.get_all_downtimes()
    downtimes[1].each do |item|
      print item['scope']
      if item['scope'] == ['env:staging']
        stagingDowntimes.push item
      end
    
    end
    
    dog.update_downtime(stagingDowntimes[0]['id'], :scope => 'env:testing', :end => Time.now.to_i + 60000, :message => "Doing some testing on staging.")
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    downtime_id=4336
    
    # Create a downtime to delete
    currenttime=$(date +%s)
    downtime_id=$(curl -X POST -H "Content-type: application/json" \
    -d "{
          \"scope\": \"env:prod\",
          \"start\": \"${currenttime}\"
        }" \
        "https://app.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    curl -X PUT -H "Content-type: application/json" \
    -d '{
          "scope": "env:staging",
          "message": "Doing some testing on staging"
        }' \
        "https://app.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'active': True,
     'disabled': False,
     'end': 1420447087,
     'id': 2910,
     'message': 'Doing some testing on staging.',
     'scope': ['env:staging'],
     'start': 1420387032}
    ["200",
     {"end"=>1418303372,
      "disabled"=>false,
      "start"=>1418224729,
      "active"=>true,
      "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", 
        "scope": [
            "env:staging"
        ], 
        "start": 1418224729
    }
    

    Cancel monitor downtime

    Arguments
  • id [required]
    The integer id of the downtime to be canceled
  • Signature
    DELETE /api/v1/downtime/:downtime_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Cancel downtime
    api.Downtime.delete(1654)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Cancel downtime
    dog.cancel_downtime(1655)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    downtime_id=1656
    
    # Create a downtime to delete
    currenttime=$(date +%s)
    downtime_id=$(curl -X POST -H "Content-type: application/json" \
    -d "{
          \"scope\": \"env:prod\",
          \"start\": \"${currenttime}\"
        }" \
        "https://app.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    curl -X DELETE -H "Content-type: application/json" "https://app.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    This end point does not return JSON on successful requests.

    Get a monitor downtime

    Arguments
    This end point takes no JSON arguments.
    Signature
    GET /api/v1/downtime/:downtime_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Get a downtime
    api.Downtime.get(2910)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    downtime_id=2473
    
    curl "https://app.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'active': True,
     'disabled': False,
     'end': 1420447087,
     'id': 2910,
     'message': 'Doing some testing on staging.',
     'scope': ['env:staging'],
     'start': 1420387032}
    {'active': True,
     'disabled': False,
     'end': 1420447087,
     'id': 2910,
     'message': 'Doing some testing on staging.',
     'scope': ['env:staging'],
     'start': 1420387032}
    

    Get all monitor downtimes

    Arguments
  • current_only [optional, default=false]
    Only return downtimes that are active when the request is made.
  • Signature
    GET /api/v1/downtime
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Get all downtimes
    print api.Downtime.get_all()
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Get all downtimes
    print(dog.get_all_downtimes())
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -G "https://app.datadoghq.com/api/v1/downtime" \
         -d "api_key=${api_key}" \
         -d "application_key=${app_key}"
    
    Example Response
    [{'active': False,
      'disabled': True,
      'end': 1412793983,
      'id': 1625,
      'scope': ['env:staging'],
      'start': 1412792983},
     {'active': False,
      'disabled': True,
      'end': None,
      'id': 1626,
      'scope': ['*'],
      'start': 1412792985}]
    ["200",
     [{"end"=>1412793983,
       "disabled"=>true,
       "start"=>1412792983,
       "active"=>false,
       "scope"=>["env:staging"],
       "id"=>1625},
      {"end"=>nil,
       "disabled"=>true,
       "start"=>1412792985,
       "active"=>false,
       "scope"=>["*"],
       "id"=>1626}]]
    [
        {
            "active": false,
            "disabled": true,
            "end": 1412793983,
            "id": 1625,
            "scope": [
                "env:staging"
            ],
            "start": 1412792983
        },
        {
            "active": false,
            "disabled": true,
            "end": null,
            "id": 1626,
            "scope": [
                "*"
            ],
            "start": 1412792985
        }
    ]
    

    Timeboards

    This endpoint allows you to programmatically create, update delete and query timeboards.

    Create a Timeboard

    Arguments
    • title [required]
      The name of the dashboard.
    • description [required]
      A description of the dashboard's content.
    • graphs [required]
      A list of graph definitions. Graph definitions follow this form:
      • title [required]
        The name of the graph.
      • definition [required]
        The graph definition. Example:
        {"requests": [{"q": "system.cpu.idle{*} by {host}"}
    • template_variables [optional, default=None]
      A list of template variables for using Dashboard templating. Template variable definitions follow this form:
      • name [required]
        The name of the variable.
      • prefix [optional, default=None]
        The tag prefix associated with the variable. Only tags with this prefix will appear in the variable dropdown.
      • default [optional, default=None]
        The default value for the template variable on dashboard load
    Signature
    POST /api/v1/dash
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    title = "My Timeboard"
    description = "An informative timeboard."
    graphs = [{
        "definition": {
            "events": [],
            "requests": [
                {"q": "avg:system.mem.free{*}"}
            ],
        "viz": "timeseries"
        },
        "title": "Average Memory Free"
    }]
    
    template_variables = [{
        "name": "host1",
        "prefix": "host",
        "default": "host:my-host"
    }]
    
    api.Timeboard.create(title=title, description=description, graphs=graphs, template_variables=template_variables)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Create a timeboard.
    title = 'My First Metrics'
    description = 'And they are marvelous.'
    graphs = [{
      "definition" => {
        "events" => [],
        "requests "=> [
          {"q" => "avg:system.mem.free{*}"}
        ],
      "viz" => "timeseries"
      },
      "title" => "Average Memory Free"
    }]
    template_variables = [{
    	"name" => "host1",
    	"prefix" => "host",
    	"default" => "host:my-host"
    }]
    
    dog.create_dashboard(title, description, graphs, template_variables)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl  -X POST -H "Content-type: application/json" \
    -d '{
          "graphs" : [{
              "title": "Average Memory Free",
              "definition": {
                  "events": [],
                  "requests": [
                      {"q": "avg:system.mem.free{*}"}
                  ]
              },
              "viz": "timeseries"
          }],
          "title" : "Average Memory Free Shell",
          "description" : "A dashboard with memory info.",
          "template_variables": [{
              "name": "host1",
              "prefix": "host",
              "default": "host:my-host"
          }]
        }' \
    "https://app.datadoghq.com/api/v1/dash?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'dash': {'description': 'An informative timeboard.',
      'graphs': [{'definition': {'events': [],
         'requests': [{'q': 'avg:system.mem.free{*}'}],
         'viz': 'timeseries'},
        'title': 'Average Memory Free'}],
      'id': 4952,
      'template_variables': [{'default': 'host:my-host',
        'name': 'host1',
        'prefix': 'host'}],
      'title': 'My Timeboard'},
     'resource': '/api/v1/dash/4952',
     'url': '/dash/dash/4952'}
    ["200",
     {"dash"=>
       {"graphs"=>
         [{"definition"=>
            {"viz"=>"timeseries",
             "events"=>[],
             "requests "=>[{"q"=>"avg:system.mem.free{*}"}]},
           "title"=>"Average Memory Free"}],
        "description"=>"And they are marvelous.",
        "id"=>2552,
        "title"=>"My First Metrics"},
      "url"=>"/dash/dash/2552",
      "resource"=>"/api/v1/dash/2552"}]
    {
        "dash": {
            "description": "A dashboard with memory info.", 
            "graphs": [
                {
                    "definition": {
                        "events": [], 
                        "requests": [
                            {
                                "q": "avg:system.mem.free{*}"
                            }
                        ]
                    }, 
                    "title": "Average Memory Free"
                }
            ], 
            "id": 2532, 
            "title": "Average Memory Free Shell"
        }, 
        "resource": "/api/v1/dash/2532", 
        "url": "/dash/dash/2532"
    }
    

    Update a Timeboard

    Arguments
    • title [required]
      The name of the dashboard.
    • description [required]
      A description of the dashboard's contents.
    • graphs [required]
      A list of graph definitions. Graph definitions follow this form:
      • title [required]
        The name of the graph.
      • definition [required]
        The graph definition. Read the Graph Guide for more on graphs. Example:
        {"requests": [{"q": "system.cpu.idle{*} by {host}"}
    • template_variables [optional, default=None]
      A list of template variables for using Dashboard templating. Template variable definitions follow this form:
      • name [required]
        The name of the variable.
      • prefix [optional, default=None]
        The tag prefix associated with the variable. Only tags with this prefix will appear in the variable dropdown.
      • default [optional, default=None]
        The default value for the template variable on dashboard load
    Signature
    PUT /api/v1/dash/:dash_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    title = "My Timeboard"
    description = "A new and improved timeboard!"
    graphs =  [{
        "definition": {
            "events": [],
            "requests": [
                {"q": "avg:system.mem.free{*} by {host}"}
            ],
        "viz": "timeseries"
        },
        "title": "Average Memory Free By Host"
    }]
    template_variables = [{
    	"name": "host1",
    	"prefix": "host",
    	"default": "host:my-host"
    }]
    
    api.Timeboard.update(4952, title=title, description=description, graphs=graphs, template_variables=template_variables)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dash_id = '2551'
    title = 'New and Improved Timeboard'
    description = 'This has all the new hotness.'
    graphs =  [{
      "definition" => {
        "events" => [],
        "requests "=> [
          {"q" => "avg:system.mem.free{*}"}
        ],
      "viz" => "timeseries"
      },
      "title" => "Average Memory Free"
    }]
    template_variables = [{
    	"name" => "host1",
    	"prefix" => "host",
    	"default" => "host:my-host"
    }]
    
    dog.update_dashboard(dash_id, title, description, graphs, template_variables)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    dash_id=2532
    
    # Create a dashboard to get. Use jq (http://stedolan.github.io/jq/download/) to get the dash id.
    dash_id=$(curl  -X POST -H "Content-type: application/json" \
    -d '{
          "graphs" : [{
              "title": "Average Memory Free",
              "definition": {
                  "events": [],
                  "requests": [
                      {"q": "avg:system.mem.free{*}"}
                  ]
              },
              "viz": "timeseries"
          }],
          "title" : "Average Memory Free Shell",
          "description" : "A dashboard with memory info.",
          "template_variables": [{
              "name": "host1",
              "prefix": "host",
              "default": "host:my-host"
          }]
        }' \
    "https://app.datadoghq.com/api/v1/dash?api_key=${api_key}&application_key=${app_key}" | jq '.dash.id')
    
    curl  -X PUT -H "Content-type: application/json" \
    -d '{
          "graphs" : [{
              "title": "Sum of Memory Free",
              "definition": {
                  "events": [],
                  "requests": [
                      {"q": "sum:system.mem.free{*}"}
                  ]
              },
              "viz": "timeseries"
          }],
          "title" : "Sum Memory Free Shell",
          "description" : "An updated dashboard with memory info.",
          "template_variables": [{
              "name": "host1",
              "prefix": "host",
              "default": "host:my-host"
          }]
        }' \
    "https://app.datadoghq.com/api/v1/dash/${dash_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'dash': {'description': 'A new and improved timeboard!',
      'graphs': [{'definition': {'events': [],
         'requests': [{'q': 'avg:system.mem.free{*} by {host}'}],
         'viz': 'timeseries'},
        'title': 'Average Memory Free By Host'}],
      'id': 4952,
      'template_variables': [{'default': 'host:my-host',
        'name': 'host1',
        'prefix': 'host'}],
      'title': 'My Timeboard'},
     'resource': '/api/v1/dash/4952',
     'url': '/dash/dash/4952'}
    ["200",
     {"dash"=>
       {"graphs"=>
         [{"definition"=>
            {"viz"=>"timeseries",
             "events"=>[],
             "requests "=>[{"q"=>"avg:system.mem.free{*}"}]},
           "title"=>"Average Memory Free"}],
        "description"=>"This has all the new hotness.",
        "id"=>2551,
        "title"=>"New and Improved Dashboard"},
      "url"=>"/dash/dash/2551",
      "resource"=>"/api/v1/dash/2551"}]
    {
        "dash": {
            "description": "A dashboard with memory info.", 
            "graphs": [
                {
                    "definition": {
                        "events": [], 
                        "requests": [
                            {
                                "q": "sum:system.mem.free{*}"
                            }
                        ]
                    }, 
                    "title": "Sum of Memory Free"
                }
            ], 
            "id": 2532, 
            "title": "Sum Memory Free Shell"
        }, 
        "resource": "/api/v1/dash/2532", 
        "url": "/dash/dash/2532"
    }
    

    Delete a Timeboard

    Delete an existing timeboard.

    This end point takes no JSON arguments.
    Signature
    DELETE /api/v1/dash/:dash_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    title = "My Timeboard"
    description = "An informative timeboard."
    graphs = [{
        "definition": {
            "events": [],
            "requests": [
                {"q": "avg:system.mem.free{*}"}
            ],
        "viz": "timeseries"
        },
        "title": "Average Memory Free"
    }]
    
    template_variables = [{
        "name": "host1",
        "prefix": "host",
        "default": "host:my-host"
    }]
    
    newboard=api.Timeboard.create(title=title, description=description, graphs=graphs, template_variables=template_variables)
    
    api.Timeboard.delete(newboard['dash']['id'])
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dash_id = '2534'
    dog.delete_dashboard(dash_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    dash_id=2471
    
    # Create a dashboard to delete. Use jq (http://stedolan.github.io/jq/download/) to get the dash id.
    dash_id=$(curl  -X POST -H "Content-type: application/json" \
    -d '{
          "graphs" : [{
              "title": "Average Memory Free",
              "definition": {
                  "events": [],
                  "requests": [
                      {"q": "avg:system.mem.free{*}"}
                  ]
              },
              "viz": "timeseries"
          }],
          "title" : "Average Memory Free Shell",
          "description" : "A dashboard with memory info.",
          "template_variables": [{
              "name": "host1",
              "prefix": "host",
              "default": "host:my-host"
          }]
        }' \
    "https://app.datadoghq.com/api/v1/dash?api_key=${api_key}&application_key=${app_key}" | jq '.dash.id')
    
    curl -X DELETE "https://app.datadoghq.com/api/v1/dash/${dash_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    This end point does not return JSON on successful requests.

    Get all Timeboards

    Fetch all of your timeboards' definitions.

    Arguments
    This end point takes no JSON arguments.
    Signature
    GET /api/v1/dash
    Example Request
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl "https://app.datadoghq.com/api/v1/dash?api_key=${api_key}&application_key=${app_key} "
    
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dog.get_dashboards
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    print api.Timeboard.get_all()
    Example Response
    {
        "dashes": [
            {
                "description": "An informative dashboard.", 
                "id": "2473", 
                "resource": "/api/v1/dash/2473", 
                "title": "My Dashboard"
            }, 
                    {
                "description": "This has all the new hotness.", 
                "id": "2551", 
                "resource": "/api/v1/dash/2551", 
                "title": "New and Improved Dashboard"
            }
        ]
    }
    
    ["200",
     {"dashes"=>
       [{"title"=>"My Dashboard",
         "resource"=>"/api/v1/dash/2473",
         "id"=>"2473",
         "description"=>"An informative dashboard."},
         {"title"=>"My First Metrics",
         "resource"=>"/api/v1/dash/2552",
         "id"=>"2552",
         "description"=>"And they are marvelous."}
        ]}]
    [{'description': 'This has all the new hotness.',
      'id': '2551',
      'resource': '/api/v1/dash/2551',
      'title': 'New and Improved Dashboard'},
     {'description': 'And they are marvelous.',
      'id': '2552',
      'resource': '/api/v1/dash/2552',
      'title': 'My First Metrics'}
    ]

    Get a Timeboard

    Fetch an existing dashboard's definition.

    Arguments
    This end point takes no JSON arguments.
    Signature
    GET /api/v1/dash/:dash_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    api.Timeboard.get(4953)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dash_id = '2542'
    dog.get_dashboard(dash_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    dash_id=2473
    
    # Create a dashboard to get. Use jq (http://stedolan.github.io/jq/download/) to get the dash id.
    dash_id=$(curl  -X POST -H "Content-type: application/json" \
    -d '{
          "graphs" : [{
              "title": "Average Memory Free",
              "definition": {
                  "events": [],
                  "requests": [
                      {"q": "avg:system.mem.free{*}"}
                  ]
              },
              "viz": "timeseries"
          }],
          "title" : "Average Memory Free Shell",
          "description" : "A dashboard with memory info.",
          "template_variables": [{
              "name": "host1",
              "prefix": "host",
              "default": "host:my-host"
          }]
        }' \
    "https://app.datadoghq.com/api/v1/dash?api_key=${api_key}&application_key=${app_key}" | jq '.dash.id')
    
    curl "https://app.datadoghq.com/api/v1/dash/${dash_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'dash': {'description': 'A new and improved timeboard!',
      'graphs': [{'definition': {'events': [],
         'requests': [{'q': 'avg:system.mem.free{*} by {host}'}],
         'viz': 'timeseries'},
        'title': 'Average Memory Free By Host'}],
      'id': 4953,
      'template_variables': [{'default': 'host:my-host',
        'name': 'host1',
        'prefix': 'host'}],
      'title': 'My Timeboard'},
     'resource': '/api/v1/dash/4953',
     'url': '/dash/dash/4953'}
    ["200",
     {"dash"=>
       {"graphs"=>
         [{"definition"=>
            {"viz"=>"timeseries",
             "events"=>[],
             "requests "=>[{"q"=>"avg:system.mem.free{*}"}]},
           "title"=>"Average Memory Free"}],
        "description"=>"desc",
        "id"=>2542,
        "title"=>"foobar"},
      "url"=>"/dash/dash/2542",
      "resource"=>"/api/v1/dash/2542"}]
    {
        "dash": {
            "description": "An informative dashboard.", 
            "graphs": [
                {
                    "definition": {
                        "events": [], 
                        "requests": [
                            {
                                "q": "avg:system.mem.free{*}"
                            }
                        ], 
                        "viz": "timeseries"
                    }, 
                    "title": "Average Memory Free"
                }
            ], 
            "id": 2473, 
            "title": "My Dashboard"
        }, 
        "resource": "/api/v1/dash/2473", 
        "url": "/dash/dash/2473"
    }
    

    Screenboards

    You can view more detailed documentation on the Screenboard API at http://docs.datadoghq.com/api/screenboards/.

    Create a Screenboard

    Arguments
    • title [required]
      The name of the dashboard.
    • description [required]
      A description of the dashboard's content.
    • graphs [required]
      A list of graph definitions. Graph definitions follow this form:
      • title [required]
        The name of the graph.
      • widgets [required]
        The widget definition. See here for more examples.
    • template_variables [optional, default=None]
      A list of template variables for using Dashboard templating.
    • width [optional, default=None]
      Screenboard width in pixels
    • height [optional, default=None]
      Height in pixels.
    Signature
    POST /api/v1/screen
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    title = "My Screenboards"
    description = "An informative screenboard."
    width = 1024
    board = [{
      "type": "image",
      "height": 20,
      "width": 32,
      "y": 7,
      "x": 32,
      "url": "https://path/to/image.jpg"
      }
      ]
    template_variables = [{
      "name": "host1",
      "prefix": "host",
      "default": "host:my-host"
    }]
    
    api.Screenboard.create(title=title, description=description, graphs=board,
      template_variables=template_variables, width=width)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    board = {
        "width" => 1024,
        "height" => 768,
        "board_title" => "dogapi test",
        "widgets" => [
            {
              "type" => "image",
              "height" => 20,
              "width" => 32,
              "y" => 7,
              "x" => 32,
              "url" => "https://path/to/image.jpg"
            }
        ]
    }
    
    result = dog.create_screenboard(board)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -X POST -H "Content-type: application/json" \
    -d '{
            "width": 1024,
            "height": 768,
            "board_title": "dogapi tests",
            "widgets": [
                {
                  "type": "image",
                  "height": 20,
                  "width": 32,
                  "y": 7,
                  "x": 32,
                  "url": "https://path/to/image.jpg"
                }
            ]
        }' \
    "https://app.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'description': 'An informative screenboard.',
     'graphs': [{'height': 20,
       'type': 'image',
       'url': 'https://path/to/image.jpg',
       'width': 32,
       'x': 32,
       'y': 7}],
     'id': 811,
     'template_variables': [{'default': 'host:my-host',
       'name': 'host1',
       'prefix': 'host'}],
     'title': 'My Screenboard',
     'width': 1024}
    ["200",
     {"board_title"=>"dogapi test",
      "width"=>1024,
      "height"=>768,
      "id"=>7952,
      "widgets"=>
       [{"url"=>"https://path/to/image.jpg",
         "height"=>20,
         "width"=>32,
         "y"=>7,
         "x"=>32,
         "type"=>"image"}]}]
    {
        "board_title": "dogapi test", 
        "height": 768, 
        "id": 7953, 
        "widgets": [
            {
                "height": 20, 
                "type": "image", 
                "url": "https://path/to/image.jpg", 
                "width": 32, 
                "x": 32, 
                "y": 7
            }
        ], 
        "width": 1024
    }
    

    Delete a Screenboard

    Delete an existing screenboard.

    This end point takes no JSON arguments.
    Signature
    DELETE /api/v1/screen/:board_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    api.Screenboard.delete(811)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    board_id = '2534'
    result = dog.delete_screenboard(board_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    board_id=2471
    
    # Create a screenboard to delete
    board_id=$(curl -X POST -H "Content-type: application/json" \
    -d '{
            "width": 1024,
            "height": 768,
            "board_title": "dogapi tests",
            "widgets": [
                {
                  "type": "image",
                  "height": 20,
                  "width": 32,
                  "y": 7,
                  "x": 32,
                  "url": "https://path/to/image.jpg"
                }
            ]
        }' \
    "https://app.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    
    curl -X DELETE \
    "https://app.datadoghq.com/api/v1/screen/${board_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    This end point does not return JSON on successful requests.

    Get a Screenboard

    Fetch an existing screenboard's definition.

    Arguments
    This end point takes no JSON arguments.
    Signature
    GET /api/v1/screen/:board_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    api.Screenboard.get(811)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    board_id = '6334'
    result = dog.get_screenboard(board_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    board_id=6334
    
    # Create a screenboard to get
    board_id=$(curl -X POST -H "Content-type: application/json" \
    -d '{
            "width": 1024,
            "height": 768,
            "board_title": "dogapi tests",
            "widgets": [
                {
                  "type": "image",
                  "height": 20,
                  "width": 32,
                  "y": 7,
                  "x": 32,
                  "url": "https://path/to/image.jpg"
                }
            ]
        }' \
    "https://app.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    
    curl -X GET \
    "https://app.datadoghq.com/api/v1/screen/${board_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'description': 'An informative screenboard.',
     'graphs': [{'height': 20,
       'type': 'image',
       'url': 'https://path/to/image.jpg',
       'width': 32,
       'x': 32,
       'y': 7}],
     'id': 811,
     'template_variables': [{'default': 'host:my-host',
       'name': 'host1',
       'prefix': 'host'}],
     'title': 'My Screenboard',
     'width': 1024}
    ["200",
     {"board_title"=>"dogapi test",
      "width"=>1024,
      "height"=>768,
      "id"=>6334,
      "widgets"=>
       [{"url"=>"http://path/to/image.jpg",
         "height"=>20,
         "width"=>32,
         "y"=>7,
         "x"=>32,
         "type"=>"image"}]}]
    {
        "board_title": "dogapi test", 
        "height": 768, 
        "id": 6334, 
        "widgets": [
            {
                "height": 20, 
                "type": "image", 
                "url": "http://path/to/image.jpg", 
                "width": 32, 
                "x": 32, 
                "y": 7
            }
        ], 
        "width": 1024
    }
    

    Get all Screenboards

    Fetch all of your screenboards' definitions.

    Arguments
    This end point takes no JSON arguments.
    Signature
    GET /api/v1/screen
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    api.Screenboard.get_all()
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -X GET "https://app.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    [{'description': 'This has all the new hotness.',
      'id': '2551',
      'resource': '/api/v1/screen/2551',
      'title': 'New and Improved Screenboard'},
     {'description': 'And they are marvelous.',
      'id': '2552',
      'resource': '/api/v1/screen/2552',
      'title': 'My First Metrics'}
    ]
    [{'description': 'This has all the new hotness.',
      'id': '2551',
      'resource': '/api/v1/screen/2551',
      'title': 'New and Improved Screenboard'},
     {'description': 'And they are marvelous.',
      'id': '2552',
      'resource': '/api/v1/screen/2552',
      'title': 'My First Metrics'}
    ]
    

    Share a Screenboard

    Share an existing screenboard's with a public URL.

    Arguments
    This end point takes no JSON arguments.
    Signature
    GET /api/v1/screen/share/:board_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    api.Screenboard.share(812)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    board_id = '6334'
    dog.share_screenboard(board_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    board_id=6334
    
    # Create a screenboard to share
    board_id=$(curl -X POST -H "Content-type: application/json" \
    -d '{
            "width": 1024,
            "height": 768,
            "board_title": "dogapi tests",
            "widgets": [
                {
                  "type": "image",
                  "height": 20,
                  "width": 32,
                  "y": 7,
                  "x": 32,
                  "url": "https://path/to/image.jpg"
                }
            ]
        }' \
    "https://app.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    
    
    curl -X GET \
    "https://app.datadoghq.com/api/v1/screen/share/${board_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'board_id': 812,
     'public_url': 'https://p.datadoghq.com/sb/20756e0cd4'}
    ["200",
     {"board_id"=>6334, "public_url"=>"https://p.datadoghq.com/sb/20756e0cd4"}]
    {
        "board_id": 6334, 
        "public_url": "https://p.datadoghq.com/sb/20756e0cd4"
    }
    

    Revoke a shared a Screenboard

    Revoke a currently shared screenboard's.

    Arguments
    This end point takes no JSON arguments.
    Signature
    DELETE /api/v1/screen/share/:board_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Share it
    api.Screenboard.share(812)
    
    # Revoke the sharing
    api.Screenboard.revoke(812)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    board_id = '6334'
    
    # Share it
    dog.share_screenboard(board_id)
    
    # Revoke the sharing
    dog.revoke_screenboard(board_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    board_id=6334
    
    # Create a screenboard to share
    board_id=$(curl -X POST -H "Content-type: application/json" \
    -d '{
            "width": 1024,
            "height": 768,
            "board_title": "dogapi tests",
            "widgets": [
                {
                  "type": "image",
                  "height": 20,
                  "width": 32,
                  "y": 7,
                  "x": 32,
                  "url": "https://path/to/image.jpg"
                }
            ]
        }' \
    "https://app.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}" | jq '.id')
    
    # Share it
    curl -X GET \
    "https://app.datadoghq.com/api/v1/screen/share/${board_id}?api_key=${api_key}&application_key=${app_key}"
    
    # Revoke the sharing
    curl -X DELETE \
    "https://app.datadoghq.com/api/v1/screen/share/${board_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    This end point does not return JSON on successful requests.

    Hosts

    Mute a Host

    Arguments
    • end [optional, default=None]
      POSIX timestamp when the host will be unmuted. If omitted, the host will remain 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, will replace existing host mute settings.
    Signature
    POST /api/v1/host/:hostname/mute
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    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)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Find a host to mute
    hosts = api.Infrastructure.search(q='hosts:')
    # Mute a host
    api.Host.mute(hosts['results']['hosts'][0])
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -X POST -H "Content-type: application/json" \
    -d '{
          "message": "Muting this host for a test!"
      }' "https://app.datadoghq.com/api/v1/host/test.host/mute?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    ["200", {"action"=>"Muted", "message"=>"Muting this host for a test.", "hostname"=>"test.host", "end"=>1433345249}]
    {'action': 'Muted', 'hostname': 'test.host'}
    {
        "action": "Muted",
        "hostname": "test.host",
        "message": "Muting this host for a test!"
    }
    

    Unmute a Host

    Arguments
    This end point takes no JSON arguments.
    Signature
    POST /api/v1/host/:hostname/unmute
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    hostname = "test.host"
    dog.unmute_host(hostname)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Find a host to unmute
    hosts = api.Infrastructure.search(q='hosts:')
    
    # Unmute host
    api.Host.unmute(hosts['results']['hosts'][0])
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -X POST -H "Content-type: application/json" "https://app.datadoghq.com/api/v1/host/test.host/unmute?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    ["200", {"action"=>"Unmuted", "hostname"=>"test.host"}]
    {'action': 'Unmuted', 'hostname': 'test.host'}
    {
        "action": "Unmuted",
        "hostname": "test.host"
    }
    

    Tags

    The tag end point allows you to tag hosts with keywords meaningful to you - like role:database. All metrics sent from a host will have its tags applied. When fetching and applying tags to a particular host, you can refer to hosts by name (yourhost.example.com).

    The component of your infrastructure responsible for a tag is identified by a source. Valid sources are: nagios, hudson, jenkins, users, feed, chef, puppet, git, bitbucket, fabric, capistrano.

    Get Tags

    Return a mapping of tags to hosts for your whole infrastructure.

    Arguments
    • source [optional, default=None]
      Only show tags from a particular source. Otherwise shows all tags.
    Signature
    GET /api/v1/tags/hosts
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dog.all_tags()
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    print api.Tag.get_all()
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl "https://app.datadoghq.com/api/v1/tags/hosts?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    ["200",
     {"tags"=>
       {"role:web"=>["test.metric.host"],
        "environment:test"=>["test.metric.host"],
        "environment:production"=>["test.another.example.com"],
        "role:webserver"=>["test.another.example.com"]}}]
    {
        "tags": {
            "role:database",
            "env:test": [
                "test.metric.host"
            ]
        }
    }
    {
        "tags": {
            "environment:production": [
                "test.another.example.com", 
                "test.host"
            ], 
            "environment:test": [
                "test.metric.host"
            ], 
            "role:database": [
                "test.metric.host"
            ], 
            "role:webserver": [
                "test.another.example.com", 
                "test.host"
            ]
        }
    }
    

    Get Host Tags

    Return the list of tags that apply to a given host.

    Arguments
    • source [optional, default=None]
      Only show tags from a particular source. Otherwise shows all tags.
    • by_source [optional, default=False]
      Return tags grouped by source.
    Signature
    GET /api/v1/tags/hosts/:host_name
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Get tags by host id.
    hosts = api.Infrastructure.search(q='hosts:')
    print api.Tag.get(hosts['results']['hosts'][0])
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    host_name = 'test.host'
    dog.host_tags(host_name)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    # pass a single hostname as an argument to search for the specified host
    host=$1
     
    # Find a host to add a tag to
    host_name=$(curl -G "https://app.datadoghq.com/api/v1/search" \
        -d "api_key=${api_key}" \
        -d "application_key=${app_key}" \
    	-d "q=hosts:$host" | cut -d'"' -f6)
     
    curl "https://app.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'tags': ['role:database','env:test']}
    ["200", {"tags"=>["role:web", "environment:test"]}]
    {
        "tags": [
            "role:database", 
            "environment:test"
        ]
    }
    

    Add Tags to a Host

    This end point allows you to add tags to a host.

    Arguments
    • tags [required]
      A list of tags to apply to the host
    • source [optional, default=users]
      The source of the tags (e.g. chef, puppet).
    Signature
    POST /api/v1/tags/hosts/:host_name
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    hosts = api.Infrastructure.search(q='hosts:')
    api.Tag.create(hosts['results']['hosts'][0], tags=["role:codesample"])
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    host=YourHostName
    
    # Find a host to add a tag to
    host_name=$(curl -G "https://app.datadoghq.com/api/v1/search" \
        -d "api_key=${api_key}" \
        -d "application_key=${app_key}" \
        -d "q=hosts:$host" | cut -d'"' -f6)
    
    curl  -X POST -H "Content-type: application/json" \
    -d "{
          \"tags\" : [\"environment:production\", \"role:webserver\"]
        }" \
    "https://app.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}"
    
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    host_name = 'test.host'
    dog.add_tags(host_name, ["role:database", "environment:production"])
    Example Response
    {'host': 'hostname', 'tags': ['role:webserver','env:production']}
    {
        "host": "test.host", 
        "tags": [
            "role:database", 
            "environment:test"
        ]
    }
    
    ["201",
     {"host"=>"test.metric.host",
      "tags"=>
       ["environment:production",
        "role:web",
        "role:database",
        "environment:test"]}]

    Update Host Tags

    This end point allows you to update all tags for a given host.

    Arguments
    • tags [required]
      A list of tags
    • source [optional, default=users]
      The source of the tags (e.g. chef, puppet).
    Signature
    PUT /api/v1/tags/hosts/:host_name
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    api.Tag.update('hostname', tags=['role:database', 'environment:test'])
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    host_name=test.host
    
    curl -X PUT -H "Content-type: application/json" \
    -d '{
          "tags" : ["environment:production", "role:webserver"]
        }' \
    "https://app.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}"
    
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    host_name = 'test.host'
    dog.update_tags(host_name, ["role:web", "environment:test"])
    Example Response
    {'host': 'hostname', 'tags': ['role:database','environment:test']}
    {
        "host": "test.host", 
        "tags": [
            "environment:production", 
            "role:webserver"
        ]
    }
    
    ["201", {"host"=>"test.metric.host", "tags"=>["role:web", "environment:test"]}]

    Remove Host Tags

    This end point allows you to remove all tags for a given host.

    Arguments
    • source [optional, default=users]
      The source of the tags (e.g. chef, puppet).
    Signature
    DELETE /api/v1/tags/hosts/:host_name
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    
    api.Tag.delete('hostname')
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    # Find a host to remove a tag from
    host_name=$(curl -G "https://app.datadoghq.com/api/v1/search" \
        -d "api_key=${api_key}" \
        -d "application_key=${app_key}" \
        -d "q=hosts:" | jq -r '.results.hosts[0]')
    # Add tags to the host
    curl  -X POST -H "Content-type: application/json" \
    -d "{\"tags\" : [\"environment:production\", \"role:webserver\"]}" \
    "https://app.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}"
    
    
    curl -X DELETE "https://app.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}"
    
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    host_name = 'test.host'
    dog.detach_tags(host_name)
    Example Response
    This end point does not return JSON on successful requests.

    This end point allows you to search for entities from the last 24 hours in Datadog. The currently searchable entities are:

    • hosts
    • metrics
    Arguments
    • q [required]
      The query string
    Query Language

    Search queries allow for limited faceting. Available facets are:

    • hosts
    • metrics

    Faceting your search limits your results to only matches of the specified type. Un-faceted queries return results for all possible types.

    Un-faceted queries are of the form:

    query_string

    Faceted queries are of the form:

    facet:query_string
    Signature
    GET /api/v1/search
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Search by `host` facet.
    api.Infrastructure.search(q="hosts:database")
    
    # Search by `metric` facet.
    api.Infrastructure.search(q="metrics:system")
    
    # Search all facets.
    api.Infrastructure.search(q="test")
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Search by `host` facet.
    dog.search("hosts:database")
    
    # Search by `metric` facet.
    dog.search("metrics:system")
    
    # Search all facets.
    dog.search("test")
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -G "https://app.datadoghq.com/api/v1/search" \
        -d "api_key=${api_key}" \
        -d "application_key=${app_key}" \
        -d "q=test"
    
    Example Response
    {'results': {'hosts': ['test.metric.host', 'test.tag.host'],
     'metrics': ['test.metric.metric', 'test.tag.metric']}}
    ["200",
     {"results"=>
       {"metrics"=>["test.metric"],
        "hosts"=>
         ["test.another.example.com",
          "test.example.com",
          "test.host",
          "test.metric.host",
          "test.tag.host"]}}]
    {
        "results": {
            "hosts": [
                "test.another.example.com", 
                "test.example.com", 
                "test.host", 
                "test.metric.host", 
                "test.tag.host"
            ], 
            "metrics": [
                "test.metric"
            ]
        }
    }
    

    Comments

    Comments are how discussion happens on Datadog. You can create, edit, delete and reply to comments.

    Create a comment

    Comments are essentially special forms of events that appear in the 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 api/v1/comments
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Start a new discussion.
    # You can include a handle like this
    api.Comment.create(handle='matt@example.com', message='Should we use COBOL or Fortran! ')
    
    # Or you can set it to None
    # and the handle will default
    # 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)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Make a comment.
    dog.comment("I have something to say.")
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl  -X POST -H "Content-type: application/json" \
    -d '{
            "message" : "There is a problem with the database."
        }' \
    "https://app.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}"
    
    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"
        }
    }
    

    Edit a Comment

    Arguments
    • message [optional, default=original message]
      The comment text.
    • handle [optional, default=application key owner]
      The handle of the user making the comment.
    Signature
    PUT api/v1/comments/:comment_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    from time import sleep
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    
    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!')
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    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")
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    comment_id=1382557387240472966
    
    # Create a comment to edit. Use jq (http://stedolan.github.io/jq/download/) to get the comment id.
    comment_id=$(curl -X POST -H "Content-type: application/json" -d '{"message" : "This comment was submitted and will be edited by the api."}' "https://app.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')
    
    curl -X PUT -H "Content-type: application/json" \
    -d '{
            "message" : "Actually, I am changing my mind."
        }' \
    "https://app.datadoghq.com/api/v1/comments/${comment_id}?api_key=${api_key}&application_key=${app_key}"
    
    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"
        }
    }
    

    Delete a Comment

    Arguments
    This end point takes no JSON arguments.
    Signature
    DELETE api/v1/comments/:comment_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    newcomment = api.Comment.create(message='Should we use COBOL or Fortran?')
    api.Comment.delete(newcomment['comment']['id'])
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dog.delete_comment("1378619807595725030")
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    # comment_id=1382559936236196216
    
    # Create a comment to delete. Use jq (http://stedolan.github.io/jq/download/) to get the comment id.
    comment_id=$(curl -X POST -H "Content-type: application/json" -d '{"message" : "This comment was submitted and will be deleted by the api."}' "https://app.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')
    sleep 1
    curl -X DELETE "https://app.datadoghq.com/api/v1/comments/${comment_id}?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    This end point does not return JSON on successful requests.

    Users

    You can invite users to join DataDog using the API.

    Invite Users

    Arguments
    • emails [required]
      A list of email addresses to send an invite to.
    Signature
    POST api/v1/invite_users
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Send invites
    api.User.invite(["jack@example.com", "jill@example.com"])
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    dog.invite(["jack@example.com", "jill@example.com"])
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key=9775a026f1ca7d1c6c5af9d94d9595a4
    app_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff
    
    curl -X POST -H "Content-type: application/json" \
    -d '{
          "emails": ["jack@example.com", "jill@example.com"]
        }' \
        "https://app.datadoghq.com/api/v1/invite_users?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {'emails': ['jack@example.com', 'jill@example.com']}
    ["200", 
        {"emails"=>["jack@example.com", "jill@example.com"]}
    ]
    {"emails": ["jack@example.com", "jill@example.com"]}

    Graphs

    You can take graph snapshots using the API.

    Graph Snapshot

    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 will add event bands to the graph.
    Signature
    GET api/v1/graph/snapshot
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    import time
    
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Take a graph snapshot
    end = int(time.time())
    start = end - (60 * 60)
    api.Graph.create(metric_query="system.load.1{*}", start=start, end=end)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    end_ts = Time.now().to_i
    start_ts = end_ts - (60 * 60)
    dog.graph_snapshot("system.load.1{*}", start_ts, end_ts)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    currenttime=$(date +%s)
    currenttime2=$(date -v -1d +%s)
    curl -G -H "Content-type: application/json" \
        -d "metric_query=system.load.1{*}" \
        -d "start=${currenttime2}" \
        -d "end=${currenttime}" \
        -d "api_key=9775a026f1ca7d1c6c5af9d94d9595a4" \
        -d "application_key=87ce4a24b5553d2e482ea8a8500e71b8ad4554ff" \
        'https://app.datadoghq.com/api/v1/graph/snapshot'
    
    Example Response
    {'graph_def': '{"requests": [{"q": "system.load.1{*}"}]}',
     '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"
    }
    

    Embeddable Graphs

    You can interact with embeddable graphs through the API.

    Get All Embeds

    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/:embed_id.

    Arguments
      This end point takes no JSON arguments.
    Signature
    GET api/v1/graph/embed
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    # Intialize request parameters including API/APP key
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Call Embed API function
    api.Embed.get_all()
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    # Initialize API Client
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Get all with API Call
    dog.get_all_embeds()
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key="9775a026f1ca7d1c6c5af9d94d9595a4"
    app_key="87ce4a24b5553d2e482ea8a8500e71b8ad4554ff"
    
    curl -X GET "https://app.datadoghq.com/api/v1/graph/embed?api_key=${api_key}&application_key=${app_key}"
    
    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
        }
      ]
    }

    Create Embed

    Creates a new embeddable graph.

    Returns: A JSON consisting of the same elements returned by GET api/v1/graph/embed/:embed_id. On failure, the return value will be a JSON containing an error message {errors: [messages]}.

    Note: If an embed already exists for the exact same query in a given organization, the older embed will be returned instead of creating a new embed.

    Arguments
    • graph_json [required]
      The graph definition in JSON. Same format that is available on the JSON tab of the graph editor
    • timeframe [optional, default=1_hour]
      The timegrame for the graph. Must be one of 1_hour, 4_hours, 1_day, 2_days, and 1_week.
    • size [optional, default=medium]
      The size of the graph. Must be one of small, medium, large, and xlarge.
    • 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 api/v1/graph/embed
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    import json
    
    # Intialize request parameters including API/APP key
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    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")
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    # Initialize API Client
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    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)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key="9775a026f1ca7d1c6c5af9d94d9595a4"
    app_key="87ce4a24b5553d2e482ea8a8500e71b8ad4554ff"
    
    curl -POST \
        -d 'graph_json={"requests":[{"q":"avg:system.load.1{*}"}],"viz":"timeseries","events":[]}' \
        -d "timeframe=1_hour" \
        -d "size=medium" \
        -d "legend=yes" \
        "https://app.datadoghq.com/api/v1/graph/embed?api_key=${api_key}&application_key=${app_key}"
    
    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 Specific Embed

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

    Returns: A JSON object with 8 elements:

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

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

    Arguments
    • size [optional, default=medium]
      The size of the graph. Must be one of small, medium, large, and xlarge.
    • legend [optional, default=no]
      The flag determining if the graph includes a legend. Must be one of yes or no.
    • template_variables [optional, default=None]
      Replace template variables in queries with form $var. To replace $var with val, use var=val as a parameter for each template variable you wish to replace. If any template variables are missing values in the iframe source url, then (*) will be used as the value.
    Signature
    GET api/v1/graph/embed/:embed_id
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    # Intialize request parameters including API/APP key
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    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")
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    # Initialize API Client
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    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)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key="9775a026f1ca7d1c6c5af9d94d9595a4"
    app_key="87ce4a24b5553d2e482ea8a8500e71b8ad4554ff"
    embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    curl -X GET "https://app.datadoghq.com/api/v1/graph/embed/${embed_id}?api_key=${api_key}&application_key=${app_key}"
    
    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 Embed

    Enable a specified embed.

    Returns: A JSON containing the success message {success: [message]}. On failure, the return value will be a JSON containing an error message {errors: [messages]}.

    Arguments
      This end point takes no JSON arguments.
    Signature
    GET api/v1/graph/embed/:embed_id/enable
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    # Intialize request parameters including API/APP key
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Set Embed ID (token)
    embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    # Call Embed API function
    api.Embed.enable(embed_id)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    # Initialize API Client
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Initialize Embed Token/ID
    embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    # Enable with API Call
    dog.enable_embed(embed_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key="9775a026f1ca7d1c6c5af9d94d9595a4"
    app_key="87ce4a24b5553d2e482ea8a8500e71b8ad4554ff"
    embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    curl -X GET "https://app.datadoghq.com/api/v1/graph/embed/${embed_id}/enable?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {
        "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
    }
    {
      "success" => "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
    }
    {
      "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
    }

    Revoke Embed

    Revoke a specified embed.

    Returns: A JSON containing the success message {success: [message]}. On failure, the return value will be a JSON containing an error message {errors: [messages]}.

    Arguments
      This end point takes no JSON arguments.
    Signature
    GET api/v1/graph/embed/:embed_id/revoke
    Example Request
    # Make sure you replace the API and or APP key below with the ones for your account
    
    from datadog import initialize, api
    
    # Intialize request parameters including API/APP key
    options = {
        'api_key': '9775a026f1ca7d1c6c5af9d94d9595a4',
        'app_key': '87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    }
    
    initialize(**options)
    
    # Set Embed ID (token)
    embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    # Call Embed API function
    api.Embed.revoke(embed_id)
    # Make sure you replace the API and or APP key below with the ones for your account
    
    require 'rubygems'
    require 'dogapi'
    
    # Initialize API Client
    api_key='9775a026f1ca7d1c6c5af9d94d9595a4'
    app_key='87ce4a24b5553d2e482ea8a8500e71b8ad4554ff'
    
    dog = Dogapi::Client.new(api_key, app_key)
    
    # Initialize Embed Token/ID
    embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    # Revoke with API Call
    dog.revoke_embed(embed_id)
    #!/bin/sh
    # Make sure you replace the API and or APP key below with the ones for your account
    
    api_key="9775a026f1ca7d1c6c5af9d94d9595a4"
    app_key="87ce4a24b5553d2e482ea8a8500e71b8ad4554ff"
    embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
    
    curl -X GET "https://app.datadoghq.com/api/v1/graph/embed/${embed_id}/revoke?api_key=${api_key}&application_key=${app_key}"
    
    Example Response
    {
        "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
    }
    {
      "success" => "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
    }
    {
      "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
    }

    Troubleshooting

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

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

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

    To check your timestamp is correct run:
    date -u && curl -s -v https://app.datadoghq.com/intake 2>&1 | grep Date
    This will output the current system’s date, and then make a request to our endpoint and grab the date on our 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 will result in a 202 'success' but no event showing up. Having an invalid source_type_name will not prevent the event from showing up, but that field will be dropped upon submission.