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.
210 lines
7.7 KiB
210 lines
7.7 KiB
const util = require("util");
|
|
|
|
module.exports = function (client) {
|
|
/*section: event
|
|
*comment: |
|
|
* create a new event
|
|
*params:
|
|
* title: the title of the event
|
|
* text: the body of the event
|
|
* properties: |
|
|
* an optional object continaing any of the following additional optional properties
|
|
* * date_happened: POSIX timestamp of when it happened
|
|
* * priority: "normal" or "low" [defualt: "normal"]
|
|
* * host: the host name to associate with the event
|
|
* * tags: array of "tag:value"'s to associate with the event
|
|
* * alert_type: "error", "warning", "info" or "success" [defualt: "info"]
|
|
* * aggregation_key: an arbitrary string used to aggregate like events
|
|
* * source_type_name: options: "nagios", "hudson", "jenkins", "user", "my apps", "feed", "chef", "puppet", "git", "bitbucket", "fabric", "capistrano"
|
|
* callback: |
|
|
* function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* const title = "some new event";
|
|
* const text = "IT HAPPENED!";
|
|
* dogapi.event.create(title, text, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* title = "another event";
|
|
* text = "IT HAPPENED AGAIN!";
|
|
* const properties = {
|
|
* tags: ["some:tag"],
|
|
* alert_type: "error"
|
|
* };
|
|
* dogapi.event.create(title, text, properties, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function create(title, text, properties, callback) {
|
|
if (arguments.length < 4 && typeof arguments[2] === "function") {
|
|
callback = properties;
|
|
properties = {};
|
|
}
|
|
if (typeof properties !== "object") {
|
|
properties = {};
|
|
}
|
|
|
|
properties.title = title;
|
|
properties.text = text;
|
|
|
|
const params = {
|
|
body: properties
|
|
};
|
|
client.request("POST", "/events", params, callback);
|
|
}
|
|
|
|
/*section: event
|
|
*comment: |
|
|
* get event details from the provided event id
|
|
*params:
|
|
* eventId: |
|
|
* the id of the event to fetch
|
|
* callback: |
|
|
* function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* dogapi.event.get(10005, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function get(eventId, callback) {
|
|
client.request("GET", util.format("/events/%s", eventId), callback);
|
|
}
|
|
|
|
/*section: event
|
|
*comment: |
|
|
* query the event stream
|
|
*params:
|
|
* start: POSIX timestamp for start of query
|
|
* end: POSIX timestamp for end of query
|
|
* parameters: |
|
|
* optional parameters to use for the query
|
|
* * priority: "low" or "normal"
|
|
* * sources: comma separated list of sources (e.g. "jenkins,user")
|
|
* * tags: comma separated list of tags (e.g. "tag:value1,tag:value2")
|
|
* callback: |
|
|
* function(err, res)
|
|
*example: |
|
|
* ```javascript
|
|
* const dogapi = require("dogapi");
|
|
* const options = {
|
|
* api_key: "api_key",
|
|
* app_key: "app_key"
|
|
* };
|
|
* dogapi.initialize(options);
|
|
* const now = parseInt(new Date().getTime() / 1000);
|
|
* const then = now - 3600; // an hour ago
|
|
* const parameters = {
|
|
* tags: "some:tag",
|
|
* sources: "jenkins"
|
|
* };
|
|
* dogapi.event.query(then, now, parameters, function(err, res){
|
|
* console.dir(res);
|
|
* });
|
|
* ```
|
|
*/
|
|
function query(start, end, parameters, callback) {
|
|
if (arguments.length < 4 && typeof argument[2] === "function") {
|
|
callback = parameters;
|
|
parameters = {};
|
|
}
|
|
|
|
if (typeof parameters !== "object") {
|
|
parameters = {}
|
|
}
|
|
parameters.start = start;
|
|
parameters.end = end;
|
|
|
|
const params = {
|
|
query: parameters
|
|
};
|
|
|
|
client.request("GET", "/events", params, callback);
|
|
}
|
|
|
|
return {
|
|
create: create,
|
|
get: get,
|
|
query: query,
|
|
getUsage: function () {
|
|
return [
|
|
" dogapi event get <event-id>",
|
|
" dogapi event query <from> <to> [--priority <priority>] [--sources <sources>] [--tags <tags>]",
|
|
" dogapi event create <title> <text> [--time <timestamp>] [--priority <priority>] [--host <host>] [--tags <tags>] [--type <type>] [--agg-key <agg-key>] [--source <source>]"
|
|
];
|
|
},
|
|
getHelp: function () {
|
|
return [
|
|
"Event:",
|
|
" Subcommands:",
|
|
" get <event-id> get the event with the provided <event-id>",
|
|
" query <from> <to> query the event stream between <from> and <to> POSIX timestamps",
|
|
" create <title> <text> create a new event with <title> and <text>",
|
|
" Options:",
|
|
" --priority <priority> the priority of the event \"normal\" or \"low\"",
|
|
" --sources <sources> a comma separated list of sources (e.g. \"users,jenkins,chef\")",
|
|
" --tags <tags> a comma separated list of \"tag:value\"'s",
|
|
" --time <time> a POSIX timestamp for when the event happened",
|
|
" --host <host> the host to associate the event to",
|
|
" --type <type> the event type \"error\", \"warning\", \"info\" or \"success\"",
|
|
" --agg-key <agg-key> an aggregation key to use to associate like events",
|
|
" --source <source> the source to associate with this event (e.g. \"users\", \"jenkins\", etc)"
|
|
];
|
|
},
|
|
handleCli: function (subcommand, args, callback) {
|
|
if (subcommand === "get" && args._.length > 4) {
|
|
get(parseInt(args._[4]), callback);
|
|
} else if (subcommand === "query" && args._.length > 5) {
|
|
const from = parseInt(args._[4]);
|
|
const to = parseInt(args._[5]);
|
|
const parameters = {};
|
|
if (args["sources"]) {
|
|
parameters.sources = args["sources"];
|
|
}
|
|
if (args["tags"]) {
|
|
parameters.tags = args["tags"];
|
|
}
|
|
query(from, to, parameters, callback);
|
|
} else if (subcommand === "create" && args._.length > 5) {
|
|
const title = args._[4];
|
|
const text = args._[5];
|
|
const properties = {};
|
|
if (args["priority"]) {
|
|
properties.priority = args["priority"];
|
|
}
|
|
if (args["host"]) {
|
|
properties.host = args["host"];
|
|
}
|
|
if (args["time"]) {
|
|
properties.date_happened = parseInt(args["time"]);
|
|
}
|
|
if (args["tags"]) {
|
|
properties.tags = args["tags"].split(",");
|
|
}
|
|
if (args["agg-key"]) {
|
|
properties.aggregation_key = args["agg-key"];
|
|
}
|
|
if (args["source"]) {
|
|
properties.source_type_name = args["source"];
|
|
}
|
|
create(title, text, properties, callback);
|
|
} else {
|
|
callback("unknown subcommand or arguments try `dogapi event --help` for help", false);
|
|
}
|
|
}
|
|
};
|
|
};
|