441 lines
12 KiB
JavaScript
441 lines
12 KiB
JavaScript
define([
|
|
'angular',
|
|
'lodash',
|
|
'kbn',
|
|
'./queryCtrl',
|
|
],
|
|
function (angular, _, kbn) {
|
|
'use strict';
|
|
|
|
var module = angular.module('grafana.services');
|
|
|
|
module.factory('ZabbixAPIDatasource', function($q, backendSrv, templateSrv) {
|
|
|
|
function ZabbixAPIDatasource(datasource) {
|
|
this.name = datasource.name;
|
|
this.url = datasource.url;
|
|
|
|
// TODO: fix passing username and password from config.html
|
|
this.username = datasource.meta.username;
|
|
this.password = datasource.meta.password;
|
|
|
|
// For testing
|
|
this.ds = datasource;
|
|
}
|
|
|
|
|
|
ZabbixAPIDatasource.prototype.query = function(options) {
|
|
// get from & to in seconds
|
|
var from = Math.ceil(kbn.parseDate(options.range.from).getTime() / 1000);
|
|
var to = Math.ceil(kbn.parseDate(options.range.to).getTime() / 1000);
|
|
|
|
// Create request for each target
|
|
var promises = _.map(options.targets, function(target) {
|
|
|
|
// Remove undefined and hidden targets
|
|
if (target.hide || !target.item) {
|
|
return [];
|
|
}
|
|
|
|
// Perform request and then handle result
|
|
return this.performTimeSeriesQuery(target.item, from, to).then(_.partial(
|
|
this.handleZabbixAPIResponse, target));
|
|
}, this);
|
|
|
|
return $q.all(promises).then(function(results) {
|
|
return { data: _.flatten(results) };
|
|
});
|
|
};
|
|
|
|
|
|
// Request data from Zabbix API
|
|
ZabbixAPIDatasource.prototype.handleZabbixAPIResponse = function(target, response) {
|
|
/**
|
|
* Response should be in the format:
|
|
* data: [
|
|
* {
|
|
* target: "Metric name",
|
|
* datapoints: [[<value>, <unixtime>], ...]
|
|
* },
|
|
* {
|
|
* target: "Metric name",
|
|
* datapoints: [[<value>, <unixtime>], ...]
|
|
* },
|
|
* ]
|
|
*/
|
|
|
|
var series = {
|
|
target: target.alias,
|
|
datapoints: _.map(response, function (p) {
|
|
// Value must be a number for properly work
|
|
var value = Number(p.value);
|
|
return [value, p.clock * 1000];
|
|
})
|
|
};
|
|
|
|
return $q.when(series);
|
|
};
|
|
|
|
|
|
// Request data from Zabbix API
|
|
ZabbixAPIDatasource.prototype.performZabbixAPIRequest = function(method, params) {
|
|
var options = {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
},
|
|
url: this.url,
|
|
data: {
|
|
jsonrpc: '2.0',
|
|
method: method,
|
|
params: params,
|
|
auth: this.auth,
|
|
id: 1
|
|
}
|
|
};
|
|
|
|
var performedQuery;
|
|
|
|
// Check authorization first
|
|
if (!this.auth) {
|
|
var self = this;
|
|
performedQuery = this.performZabbixAPILogin().then(function (response) {
|
|
self.auth = response;
|
|
options.data.auth = response;
|
|
return backendSrv.datasourceRequest(options);
|
|
});
|
|
} else {
|
|
performedQuery = backendSrv.datasourceRequest(options);
|
|
}
|
|
|
|
// Handle response
|
|
return performedQuery.then(function (response) {
|
|
if (!response.data) {
|
|
return [];
|
|
}
|
|
return response.data.result;
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* Perform time series query to Zabbix API
|
|
*
|
|
* @param items: array of zabbix api item objects
|
|
*/
|
|
ZabbixAPIDatasource.prototype.performTimeSeriesQuery = function(items, start, end) {
|
|
var params = {
|
|
output: 'extend',
|
|
history: items.value_type,
|
|
itemids: items.itemid,
|
|
sortfield: 'clock',
|
|
sortorder: 'ASC',
|
|
time_from: start
|
|
};
|
|
|
|
// Relative queries (e.g. last hour) don't include an end time
|
|
if (end) {
|
|
params.time_till = end;
|
|
}
|
|
|
|
return this.performZabbixAPIRequest('history.get', params);
|
|
};
|
|
|
|
|
|
// Get authentication token
|
|
ZabbixAPIDatasource.prototype.performZabbixAPILogin = function() {
|
|
var options = {
|
|
url : this.url,
|
|
method : 'POST',
|
|
data: {
|
|
jsonrpc: '2.0',
|
|
method: 'user.login',
|
|
params: {
|
|
user: this.username,
|
|
password: this.password
|
|
},
|
|
auth: null,
|
|
id: 1
|
|
},
|
|
};
|
|
|
|
return backendSrv.datasourceRequest(options).then(function (result) {
|
|
if (!result.data) {
|
|
return null;
|
|
}
|
|
return result.data.result;
|
|
});
|
|
};
|
|
|
|
|
|
// Get the list of host groups
|
|
ZabbixAPIDatasource.prototype.performHostGroupSuggestQuery = function() {
|
|
var params = {
|
|
output: ['name'],
|
|
real_hosts: true, //Return only host groups that contain hosts
|
|
sortfield: 'name'
|
|
};
|
|
|
|
return this.performZabbixAPIRequest('hostgroup.get', params);
|
|
};
|
|
|
|
|
|
// Get the list of hosts
|
|
ZabbixAPIDatasource.prototype.performHostSuggestQuery = function(groupid) {
|
|
var params = {
|
|
output: ['name', 'host'],
|
|
sortfield: 'name'
|
|
};
|
|
// Return only hosts in given group
|
|
if (groupid) {
|
|
params.groupids = groupid;
|
|
}
|
|
return this.performZabbixAPIRequest('host.get', params);
|
|
};
|
|
|
|
|
|
// Get the list of applications
|
|
ZabbixAPIDatasource.prototype.performAppSuggestQuery = function(hostid) {
|
|
var params = {
|
|
output: ['name'],
|
|
sortfield: 'name',
|
|
hostids: hostid
|
|
};
|
|
|
|
return this.performZabbixAPIRequest('application.get', params);
|
|
};
|
|
|
|
|
|
// Get the list of host items
|
|
ZabbixAPIDatasource.prototype.performItemSuggestQuery = function(hostid, applicationid) {
|
|
var params = {
|
|
output: ['name', 'key_', 'value_type', 'delay'],
|
|
sortfield: 'name',
|
|
hostids: hostid,
|
|
|
|
//Include web items in the result
|
|
webitems: true,
|
|
// Return only numeric items
|
|
filter: {
|
|
value_type: [0,3]
|
|
}
|
|
};
|
|
// If application selected return only relative items
|
|
if (applicationid) {
|
|
params.applicationids = applicationid;
|
|
}
|
|
|
|
return this.performZabbixAPIRequest('item.get', params);
|
|
};
|
|
|
|
|
|
ZabbixAPIDatasource.prototype.findZabbixGroup = function (group) {
|
|
var params = {
|
|
output: ['name'],
|
|
search: {
|
|
name: group
|
|
},
|
|
searchWildcardsEnabled: true
|
|
}
|
|
return this.performZabbixAPIRequest('hostgroup.get', params);
|
|
};
|
|
|
|
|
|
ZabbixAPIDatasource.prototype.findZabbixHost = function (hostname) {
|
|
var params = {
|
|
output: ['host', 'name'],
|
|
search: {
|
|
host: hostname,
|
|
name: hostname
|
|
},
|
|
searchWildcardsEnabled: true,
|
|
searchByAny: true
|
|
}
|
|
return this.performZabbixAPIRequest('host.get', params);
|
|
};
|
|
|
|
|
|
ZabbixAPIDatasource.prototype.findZabbixApp = function (application) {
|
|
var params = {
|
|
output: ['name'],
|
|
search: {
|
|
name: application
|
|
},
|
|
searchWildcardsEnabled: true
|
|
}
|
|
return this.performZabbixAPIRequest('application.get', params);
|
|
};
|
|
|
|
// For templated query
|
|
ZabbixAPIDatasource.prototype.metricFindQuery = function (query) {
|
|
var interpolated;
|
|
try {
|
|
interpolated = encodeURIComponent(templateSrv.replace(query));
|
|
}
|
|
catch (err) {
|
|
return $q.reject(err);
|
|
}
|
|
|
|
// Split query. Query structure:
|
|
// group.host.app.key
|
|
var parts = [];
|
|
_.each(query.split('.'), function (part) {
|
|
part = templateSrv.replace(part);
|
|
if (part[0] === '{') {
|
|
parts.push(part.slice(1, -1).split(','));
|
|
} else {
|
|
parts.push(part);
|
|
}
|
|
});
|
|
var template = _.object(['group', 'host', 'app', 'key'], parts)
|
|
|
|
var params = {
|
|
output: ['name'],
|
|
sortfield: 'name',
|
|
// Case insensitive search
|
|
search: {
|
|
name : template.group
|
|
}
|
|
};
|
|
|
|
// Get items
|
|
if (parts.length === 4) {
|
|
var params = {
|
|
output: ['name', 'key_'],
|
|
sortfield: 'name',
|
|
};
|
|
if (template.group != '*' && template.group) {
|
|
params.group = template.group;
|
|
}
|
|
if (template.host != '*' && template.host) {
|
|
params.host = template.host;
|
|
}
|
|
if (template.application != '*' && template.application) {
|
|
params.application = template.app;
|
|
}
|
|
return this.performZabbixAPIRequest('item.get', params)
|
|
.then(function (result) {
|
|
return _.map(result, function (item) {
|
|
return {
|
|
text: item.key_,
|
|
expandable: false
|
|
};
|
|
});
|
|
});
|
|
}
|
|
// Get applications
|
|
else if (parts.length === 3) {
|
|
return this.appFindQuery(template);
|
|
}
|
|
// Return empty object
|
|
else {
|
|
var d = $q.defer();
|
|
d.resolve({ data: [] });
|
|
return d.promise;
|
|
}
|
|
};
|
|
|
|
ZabbixAPIDatasource.prototype.appFindQuery = function(template) {
|
|
var params = {
|
|
output: ['name'],
|
|
sortfield: 'name'
|
|
};
|
|
var promises = [];
|
|
if (template.group != '*' && template.group) {
|
|
if (_.isArray(template.group)) {
|
|
_.each(template.group, function (group) {
|
|
promises.push(this.findZabbixGroup(group));
|
|
}, this);
|
|
} else {
|
|
promises.push(this.findZabbixGroup(template.group));
|
|
}
|
|
}
|
|
if (template.host != '*' && template.host) {
|
|
if (_.isArray(template.host)) {
|
|
_.each(template.host, function (host) {
|
|
promises.push(this.findZabbixHost(host));
|
|
}, this);
|
|
} else {
|
|
promises.push(this.findZabbixHost(template.host));
|
|
}
|
|
}
|
|
|
|
var self = this;
|
|
return $q.all(promises).then(function (results) {
|
|
results = _.flatten(results);
|
|
var groupids = _.map(_.filter(results, function (object) {
|
|
return object.groupid;
|
|
}), 'groupid');
|
|
var hostids = _.map(_.filter(results, function (object) {
|
|
return object.hostid;
|
|
}), 'hostid');
|
|
|
|
var params = {
|
|
output: ['name']
|
|
}
|
|
if (hostids) {
|
|
params.hostids = hostids;
|
|
} else if (groupids) {
|
|
params.groupids = groupids;
|
|
}
|
|
|
|
return self.performZabbixAPIRequest('application.get', params)
|
|
.then(function (result) {
|
|
return _.map(result, function (app) {
|
|
return {
|
|
text: app.name,
|
|
expandable: false
|
|
};
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
ZabbixAPIDatasource.prototype.annotationQuery = function(annotation, rangeUnparsed) {
|
|
var from = Math.ceil(kbn.parseDate(rangeUnparsed.from).getTime() / 1000);
|
|
var to = Math.ceil(kbn.parseDate(rangeUnparsed.to).getTime() / 1000);
|
|
var self = this;
|
|
|
|
var params = {
|
|
output: ['triggerid', 'description'],
|
|
search: {
|
|
'description': annotation.query
|
|
},
|
|
};
|
|
|
|
return this.performZabbixAPIRequest('trigger.get', params).then(function (result) {
|
|
if(result) {
|
|
var obs = {};
|
|
obs = _.indexBy(result, 'triggerid');
|
|
|
|
var params = {
|
|
output: 'extend',
|
|
sortorder: 'DESC',
|
|
time_from: from,
|
|
time_till: to,
|
|
objectids: _.keys(obs)
|
|
};
|
|
|
|
return self.performZabbixAPIRequest('event.get', params).then(function (result) {
|
|
var events = [];
|
|
_.each(result, function(e) {
|
|
events.push({
|
|
annotation: annotation,
|
|
time: e.clock * 1000,
|
|
title: obs[e.objectid].description,
|
|
text: e.eventid,
|
|
});
|
|
});
|
|
return events;
|
|
});
|
|
} else {
|
|
return [];
|
|
}
|
|
});
|
|
};
|
|
|
|
return ZabbixAPIDatasource;
|
|
});
|
|
});
|