You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
451 lines
14 KiB
451 lines
14 KiB
const util = require('util');
|
|
|
|
module.exports = function(client) {
|
|
/* section: monitor
|
|
*comment: create a new monitor
|
|
*params:
|
|
* type: one of "metric alert" or "service check"
|
|
* query: the monitor query to use, you probably want to read datadog's [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs
|
|
* properties: |
|
|
* optional, an object containing any of the following
|
|
* * name: the name of the monitor
|
|
* * message: the message for the monitor
|
|
* * tags: a list of strings as tags to associate with the monitor
|
|
* * options: an object, to see available options please see the [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* const metricType = "metric alert";
|
|
* const query = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100";
|
|
* dogapi.monitor.create(metricType, query, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function create(type, query, properties, callback) {
|
|
if (arguments.length < 4 && typeof arguments[2] === 'function') {
|
|
callback = properties;
|
|
properties = {};
|
|
}
|
|
|
|
const params = {
|
|
body: {
|
|
type,
|
|
query
|
|
}
|
|
};
|
|
|
|
if (typeof properties === 'object') {
|
|
if (properties.name) {
|
|
params.body.name = properties.name;
|
|
}
|
|
if (properties.message) {
|
|
params.body.message = properties.message;
|
|
}
|
|
if (properties.tags) {
|
|
params.body.tags = properties.tags;
|
|
}
|
|
if (typeof properties.options === 'object') {
|
|
params.body.options = properties.options;
|
|
}
|
|
}
|
|
client.request('POST', '/monitor', params, callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: get an existing monitor's details
|
|
*params:
|
|
* monitorId: the id of the monitor
|
|
* groupStates: an array containing any of the following "all", "alert", "warn", or "no data"
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.get(1234, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function get(monitorId, groupStates, callback) {
|
|
if (arguments.length < 3 && typeof arguments[1] === 'function') {
|
|
callback = groupStates;
|
|
groupStates = undefined;
|
|
}
|
|
|
|
const params = {};
|
|
if (groupStates) {
|
|
params.query = {
|
|
group_states: groupStates.join(',')
|
|
};
|
|
}
|
|
|
|
client.request('GET', util.format('/monitor/%s', monitorId), params, callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: get all monitors
|
|
*params:
|
|
* options: |
|
|
* optional, an object containing any of the following
|
|
* * group_states: an array containing any of the following "all", "alert", "warn", or "no data"
|
|
* * tags: an array of "tag:value"'s to filter on
|
|
* * monitor_tags: a comma separated list indicating what service and/or custom tags
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.getAll(function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function getAll(options, callback) {
|
|
if (arguments.length < 2 && typeof arguments[0] === 'function') {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
const params = {};
|
|
if (typeof options === 'object') {
|
|
params.query = {};
|
|
if (options.group_states) {
|
|
params.query.group_states = options.group_states.join(',');
|
|
}
|
|
if (options.tags) {
|
|
params.query.tags = options.tags.join(',');
|
|
}
|
|
if (options.monitor_tags) {
|
|
params.query.monitor_tags = options.monitor_tags.join(',');
|
|
}
|
|
}
|
|
client.request('GET', '/monitor', params, callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: update a monitor's details
|
|
*params:
|
|
* monitorId: the id of the monitor to edit
|
|
* query: the query that the monitor should have, see the [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs for more info
|
|
* properties: |
|
|
* optional, an object containing any of the following
|
|
* * name: the name of the monitor
|
|
* * message: the message for the monitor
|
|
* * tags: a list of strings as tags to associate with the monitor
|
|
* * options: an object, to see available options please see the [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* const query = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100";
|
|
* dogapi.monitor.update(1234, query, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function update(monitorId, query, properties, callback) {
|
|
if (arguments.length < 4 && typeof arguments[2] === 'function') {
|
|
callback = properties;
|
|
properties = {};
|
|
}
|
|
|
|
const params = {
|
|
body: {
|
|
query
|
|
}
|
|
};
|
|
|
|
if (typeof properties === 'object') {
|
|
if (properties.name) {
|
|
params.body.name = properties.name;
|
|
}
|
|
if (properties.message) {
|
|
params.body.message = properties.message;
|
|
}
|
|
if (properties.tags) {
|
|
params.body.tags = properties.tags;
|
|
}
|
|
if (typeof properties.options === 'object') {
|
|
params.body.options = properties.options;
|
|
}
|
|
}
|
|
client.request('PUT', util.format('/monitor/%s', monitorId), params, callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: delete an existing monitor
|
|
*params:
|
|
* monitorId: the id of the monitor to remove
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.remove(1234, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function remove(monitorId, callback) {
|
|
client.request('DELETE', util.format('/monitor/%s', monitorId), callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: mute an existing monitor
|
|
*params:
|
|
* monitorId: the id of the monitor to mute
|
|
* options: |
|
|
* optional, an object containing any of the following
|
|
* * scope: the scope to mute (e.g. "role:db")
|
|
* * end: POSIX timestamp indicating when the mute should end
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.mute(1234, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function mute(monitorId, options, callback) {
|
|
if (arguments.length < 3 && typeof arguments[1] === 'function') {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
const params = {};
|
|
if (typeof options === 'object') {
|
|
params.body = {};
|
|
if (options.scope) {
|
|
params.body.scope = options.scope;
|
|
}
|
|
if (options.end) {
|
|
params.body.end = parseInt(options.end);
|
|
}
|
|
} else {
|
|
params.body = ''; // create empty body
|
|
}
|
|
client.request('POST', util.format('/monitor/%s/mute', monitorId), params, callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: mute all monitors
|
|
*params:
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.muteAll(function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function muteAll(callback) {
|
|
client.request('POST', '/monitor/mute_all', callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: unmute an existing monitor
|
|
*params:
|
|
* monitorId: the id of the monitor to unmute
|
|
* scope: optional, a scope to apply the unmute to (e.g. "role:db")
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.unmute(1234, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function unmute(monitorId, scope, callback) {
|
|
if (arguments.length < 3 && typeof arguments[1] === 'function') {
|
|
callback = scope;
|
|
scope = undefined;
|
|
}
|
|
const params = {};
|
|
if (scope) {
|
|
params.body = {
|
|
scope
|
|
};
|
|
} else {
|
|
params.body = ''; // create empty body
|
|
}
|
|
client.request('POST', util.format('/monitor/%s/unmute', monitorId), params, callback);
|
|
}
|
|
|
|
/* section: monitor
|
|
*comment: unmute all monitors
|
|
*params:
|
|
* callback: function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.monitor.unmuteAll(function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function unmuteAll(callback) {
|
|
client.request('POST', '/monitor/unmute_all', callback);
|
|
}
|
|
|
|
return {
|
|
create,
|
|
get,
|
|
update,
|
|
remove,
|
|
getAll,
|
|
mute,
|
|
muteAll,
|
|
unmute,
|
|
unmuteAll,
|
|
getUsage() {
|
|
return [
|
|
' dogapi monitor create <type> <query> [--name <name>] [--message <message>]',
|
|
' dogapi monitor get <monitor-id> [--states <states>]',
|
|
' dogapi monitor getall [--states <states>] [--tags <tags>]',
|
|
' dogapi monitor mute <monitor-id> [--scope <scope>] [--end <end>]',
|
|
' dogapi monitor muteall',
|
|
' dogapi monitor remove <monitor-id>',
|
|
' dogapi monitor unmute <monitor-id> [--scope <scope>]',
|
|
' dogapi monitor unmuteall',
|
|
' dogapi monitor update <monitor-id> <query> [--name <name>] [--message <message>]'
|
|
];
|
|
},
|
|
getHelp() {
|
|
return [
|
|
'Monitor:',
|
|
' Subcommands:',
|
|
' create <type> <query> create a new monitor',
|
|
' get <monitor-id> get a monitors details',
|
|
' getall get a list of all monitors',
|
|
' mute <monitor-id> mute the monitor with the id <monitor-id>',
|
|
' muteall mute all monitors',
|
|
' remove <monitor-id> delete the monitor with the id <monitor-id>',
|
|
' unmute <monitor-id> unmute the monitor with the id <monitor-id>',
|
|
' unmuteall unmute all monitors',
|
|
' update <monitor-id> <query> update an existing monitor',
|
|
'',
|
|
' Options:',
|
|
' --states <states> a comma separated list containing any of "all", "alert", "warn", or "no data"',
|
|
' --tags <tags> a comma separated list of "tag:value"\'s',
|
|
' --scope <scope> the scope of the monitor to mute (e.g. "role:db")',
|
|
' --end <end> POSIX timestamp for when the mute should end',
|
|
' --name <name> the name for the monitor',
|
|
' --message <message> the message for the monitor'
|
|
];
|
|
},
|
|
handleCli(subcommand, args, callback) {
|
|
const states = args.states ? args.states.split(',') : [];
|
|
const tags = args.tags ? args.tags.split(',') : [];
|
|
|
|
const name = args.name;
|
|
const message = args.message;
|
|
|
|
if (subcommand === 'get') {
|
|
const monitorId = args._[4];
|
|
get(monitorId, states, callback);
|
|
} else if (subcommand === 'getall') {
|
|
const options = {};
|
|
if (states.length > 0) {
|
|
options.group_states = states;
|
|
}
|
|
if (tags.length > 0) {
|
|
options.tags = tags;
|
|
}
|
|
getAll(options, callback);
|
|
} else if (subcommand === 'mute') {
|
|
const monitorId = args._[4];
|
|
const options = {};
|
|
if (args.scope) {
|
|
options.scope = args.scope;
|
|
}
|
|
if (args.end) {
|
|
options.end = args.end;
|
|
}
|
|
mute(monitorId, options, callback);
|
|
} else if (subcommand === 'unmute') {
|
|
const monitorId = args._[4];
|
|
const scope = args.scope;
|
|
unmute(monitorId, scope, callback);
|
|
} else if (subcommand === 'unmuteall') {
|
|
unmuteAll(callback);
|
|
} else if (subcommand === 'muteall') {
|
|
muteAll(callback);
|
|
} else if (subcommand === 'remove') {
|
|
const monitorId = args._[4];
|
|
remove(monitorId, callback);
|
|
} else if (subcommand === 'create' && args._.length > 5) {
|
|
const type = args._[4];
|
|
const query = args._[5];
|
|
const properties = {};
|
|
if (name) {
|
|
properties.name = name;
|
|
}
|
|
if (message) {
|
|
properties.message = message;
|
|
}
|
|
create(type, query, properties, callback);
|
|
} else if (subcommand === 'update' && args._.length > 5) {
|
|
const monitorId = args._[4];
|
|
const query = args._[5];
|
|
const properties = {};
|
|
if (name) {
|
|
properties.name = name;
|
|
}
|
|
if (message) {
|
|
properties.message = message;
|
|
}
|
|
update(monitorId, query, properties, callback);
|
|
} else {
|
|
return callback(
|
|
'unknown subcommand or arguments try `dogapi monitor --help` for help',
|
|
false
|
|
);
|
|
}
|
|
}
|
|
};
|
|
};
|