Misthios/grafana-zabbix
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Initial ES6 migration. module.js and datasource.js are migrated to ES6.

Browse Source
This commit is contained in:
Alexander Zobnin
2016-03-14 23:42:24 +03:00
parent 50c0764d01
commit 8b37478131
31 changed files with 567 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
.gitignore vendored
View File

@@ -12,3 +12,18 @@
# Builded docs # Builded docs
docs/site/ docs/site/
node_modules
npm-debug.log
coverage/
.aws-config.json
awsconfig
/emails/dist
/public_gen
/tmp
vendor/phantomjs/phantomjs
dist/
# locally required config files
public/css/*.min.css

6
.jshintrc
View File

@@ -4,7 +4,7 @@
"bitwise":false, "bitwise":false,
"curly": true, "curly": true,
"eqnull": true, "eqnull": true,
"globalstrict": true, "strict": true,
"devel": true, "devel": true,
"eqeqeq": true, "eqeqeq": true,
"forin": false, "forin": false,
@@ -12,7 +12,7 @@
"supernew": true, "supernew": true,
"expr": true, "expr": true,
"indent": 2, "indent": 2,
"latedef": true, "latedef": false,
"newcap": true, "newcap": true,
"noarg": true, "noarg": true,
"noempty": true, "noempty": true,
@@ -25,9 +25,11 @@
"unused": true, "unused": true,
"maxdepth": 6, "maxdepth": 6,
"maxlen": 140, "maxlen": 140,
"esnext": true,
"globals": { "globals": {
"System": true, "System": true,
"Promise": true,
"define": true, "define": true,
"require": true, "require": true,
"Chromath": false, "Chromath": false,

62
Gruntfile.js Normal file
View File

@@ -0,0 +1,62 @@
module.exports = function(grunt) {
require('load-grunt-tasks')(grunt);
grunt.loadNpmTasks('grunt-execute');
grunt.loadNpmTasks('grunt-contrib-clean');
grunt.initConfig({
clean: ["dist"],
copy: {
src_to_dist: {
cwd: 'src',
expand: true,
src: [
'**/*',
'!**/datasource.js',
'!**/module.js',
'!**/*.scss'
],
dest: 'dist/src'
},
pluginDef: {
expand: true,
src: ['plugin.json', 'README.md'],
dest: 'dist',
}
},
watch: {
rebuild_all: {
files: ['src/**/*', 'plugin.json'],
tasks: ['default'],
options: {spawn: false}
},
},
babel: {
options: {
sourceMap: true,
presets: ["es2015"],
plugins: ['transform-es2015-modules-systemjs', "transform-es2015-for-of"],
},
dist: {
files: [{
cwd: 'src',
expand: true,
src: [
'**/**/datasource.js',
'**/**/module.js',
],
dest: 'dist/src',
ext:'.js'
}]
},
},
});
grunt.registerTask('default', ['clean', 'copy:src_to_dist', 'copy:pluginDef', 'babel']);
};

37
package.json Normal file
View File

@@ -0,0 +1,37 @@
{
"name": "grafana-zabbix",
"private": false,
"version": "3.0.0",
"description": "",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/alexanderzobnin/grafana-zabbix.git"
},
"author": "Alexander Zobnin",
"license": "Apache-2.0",
"bugs": {
"url": "https://github.com/alexanderzobnin/grafana-zabbix/issues"
},
"devDependencies": {
"grunt": "~0.4.5",
"babel": "~6.5.1",
"grunt-babel": "~6.0.0",
"grunt-contrib-copy": "~0.8.2",
"grunt-contrib-watch": "^0.6.1",
"grunt-contrib-uglify": "~0.11.0",
"grunt-systemjs-builder": "^0.2.5",
"load-grunt-tasks": "~3.2.0",
"grunt-execute": "~0.2.2",
"grunt-contrib-clean": "~0.6.0"
},
"dependencies": {
"babel-plugin-transform-es2015-modules-systemjs": "^6.5.0",
"babel-plugin-transform-es2015-for-of": "^6.5.0",
"babel-preset-es2015": "^6.5.0",
"lodash": "~4.0.0"
},
"homepage": "http://grafana-zabbix.org"
}

429
plugins/datasource-zabbix/datasource.js
View File

@@ -1,429 +0,0 @@
define([
'angular',
'lodash',
'app/core/utils/datemath',
'./utils',
'./metricFunctions',
'./queryProcessor',
'./directives',
'./zabbixAPI',
'./helperFunctions',
'./dataProcessingService',
'./zabbixCache',
'./queryCtrl',
'./addMetricFunction',
'./metricFunctionEditor'
],
function (angular, _, dateMath, utils, metricFunctions) {
'use strict';
/** @ngInject */
function ZabbixAPIDatasource(instanceSettings, $q, templateSrv, alertSrv, zabbixHelperSrv,
ZabbixAPI, ZabbixCachingProxy, QueryProcessor, DataProcessingService) {
// General data source settings
this.name = instanceSettings.name;
this.url = instanceSettings.url;
this.basicAuth = instanceSettings.basicAuth;
this.withCredentials = instanceSettings.withCredentials;
// Zabbix API credentials
this.username = instanceSettings.jsonData.username;
this.password = instanceSettings.jsonData.password;
// Use trends instead history since specified time
this.trends = instanceSettings.jsonData.trends;
this.trendsFrom = instanceSettings.jsonData.trendsFrom || '7d';
// Set cache update interval
var ttl = instanceSettings.jsonData.cacheTTL || '1h';
this.cacheTTL = utils.parseInterval(ttl);
// Initialize Zabbix API
this.zabbixAPI = new ZabbixAPI(this.url, this.username, this.password, this.basicAuth, this.withCredentials);
// Initialize cache service
this.zabbixCache = new ZabbixCachingProxy(this.zabbixAPI, this.cacheTTL);
// Initialize query builder
this.queryProcessor = new QueryProcessor(this.zabbixCache);
console.log(this.zabbixCache);
////////////////////////
// Datasource methods //
////////////////////////
/**
* Test connection to Zabbix API
* @return {object} Connection status and Zabbix API version
*/
this.testDatasource = function() {
var self = this;
return this.zabbixAPI.getVersion().then(function (version) {
return self.zabbixAPI.login().then(function (auth) {
if (auth) {
return {
status: "success",
title: "Success",
message: "Zabbix API version: " + version
};
} else {
return {
status: "error",
title: "Invalid user name or password",
message: "Zabbix API version: " + version
};
}
}, function(error) {
console.log(error);
return {
status: "error",
title: "Connection failed",
message: error
};
});
},
function(error) {
console.log(error);
return {
status: "error",
title: "Connection failed",
message: "Could not connect to given url"
};
});
};
/**
* Query panel data. Calls for each panel in dashboard.
* @param {Object} options Contains time range, targets and other info.
* @return {Object} Grafana metrics object with timeseries data for each target.
*/
this.query = function(options) {
var self = this;
// get from & to in seconds
var from = Math.ceil(dateMath.parse(options.range.from) / 1000);
var to = Math.ceil(dateMath.parse(options.range.to) / 1000);
var useTrendsFrom = Math.ceil(dateMath.parse('now-' + this.trendsFrom) / 1000);
// Create request for each target
var promises = _.map(options.targets, function(target) {
if (target.mode !== 1) {
// Don't request undefined and hidden targets
if (target.hide || !target.group ||
!target.host || !target.item) {
return [];
}
// Replace templated variables
var groupFilter = templateSrv.replace(target.group.filter, options.scopedVars);
var hostFilter = templateSrv.replace(target.host.filter, options.scopedVars);
var appFilter = templateSrv.replace(target.application.filter, options.scopedVars);
var itemFilter = templateSrv.replace(target.item.filter, options.scopedVars);
// Query numeric data
if (!target.mode || target.mode === 0) {
// Build query in asynchronous manner
return self.queryProcessor.build(groupFilter, hostFilter, appFilter, itemFilter)
.then(function(items) {
// Add hostname for items from multiple hosts
var addHostName = target.host.isRegex;
var getHistory;
// Use trends
if ((from < useTrendsFrom) && self.trends) {
// Find trendValue() function and get specified trend value
var trendFunctions = _.map(metricFunctions.getCategories()['Trends'], 'name');
var trendValueFunc = _.find(target.functions, function(func) {
return _.contains(trendFunctions, func.def.name);
});
var valueType = trendValueFunc ? trendValueFunc.params[0] : "avg";
getHistory = self.zabbixAPI.getTrend(items, from, to).then(function(history) {
return self.queryProcessor.handleTrends(history, addHostName, valueType);
});
} else {
// Use history
getHistory = self.zabbixCache.getHistory(items, from, to).then(function(history) {
return self.queryProcessor.handleHistory(history, addHostName);
});
}
return getHistory.then(function (timeseries_data) {
timeseries_data = _.map(timeseries_data, function (timeseries) {
// Filter only transform functions
var transformFunctions = bindFunctionDefs(target.functions, 'Transform');
// Metric data processing
var dp = timeseries.datapoints;
for (var i = 0; i < transformFunctions.length; i++) {
dp = transformFunctions[i](dp);
}
timeseries.datapoints = dp;
return timeseries;
});
// Aggregations
var aggregationFunctions = bindFunctionDefs(target.functions, 'Aggregate');
var dp = _.map(timeseries_data, 'datapoints');
if (aggregationFunctions.length) {
for (var i = 0; i < aggregationFunctions.length; i++) {
dp = aggregationFunctions[i](dp);
}
var lastAgg = _.findLast(target.functions, function(func) {
return _.contains(
_.map(metricFunctions.getCategories()['Aggregate'], 'name'), func.def.name);
});
timeseries_data = [{
target: lastAgg.text,
datapoints: dp
}];
}
// Apply alias functions
var aliasFunctions = bindFunctionDefs(target.functions, 'Alias');
for (var j = 0; j < aliasFunctions.length; j++) {
_.each(timeseries_data, aliasFunctions[j]);
}
return timeseries_data;
});
});
}
// Query text data
else if (target.mode === 2) {
return self.queryProcessor.build(groupFilter, hostFilter, appFilter, itemFilter)
.then(function(items) {
var deferred = $q.defer();
if (items.length) {
self.zabbixAPI.getLastValue(items[0].itemid).then(function(lastvalue) {
if (target.textFilter) {
var text_extract_pattern = new RegExp(templateSrv.replace(target.textFilter, options.scopedVars));
var result = text_extract_pattern.exec(lastvalue);
if (result) {
if (target.useCaptureGroups) {
result = result[1];
} else {
result = result[0];
}
}
deferred.resolve(result);
} else {
deferred.resolve(lastvalue);
}
});
} else {
deferred.resolve(null);
}
return deferred.promise.then(function(text) {
return {
target: target.item.name,
datapoints: [[text, to * 1000]]
};
});
});
}
}
// IT services mode
else if (target.mode === 1) {
// Don't show undefined and hidden targets
if (target.hide || !target.itservice || !target.slaProperty) {
return [];
} else {
return this.zabbixAPI.getSLA(target.itservice.serviceid, from, to)
.then(_.bind(zabbixHelperSrv.handleSLAResponse, zabbixHelperSrv, target.itservice, target.slaProperty));
}
}
}, this);
// Data for panel (all targets)
return $q.all(_.flatten(promises))
.then(_.flatten)
.then(function (timeseries_data) {
// Series downsampling
var data = _.map(timeseries_data, function(timeseries) {
var DPS = DataProcessingService;
if (timeseries.datapoints.length > options.maxDataPoints) {
timeseries.datapoints = DPS.groupBy(options.interval, DPS.AVERAGE, timeseries.datapoints);
}
return timeseries;
});
return { data: data };
});
};
function bindFunctionDefs(functionDefs, category) {
var aggregationFunctions = _.map(metricFunctions.getCategories()[category], 'name');
var aggFuncDefs = _.filter(functionDefs, function(func) {
return _.contains(aggregationFunctions, func.def.name);
});
return _.map(aggFuncDefs, function(func) {
var funcInstance = metricFunctions.createFuncInstance(func.def, func.params);
return funcInstance.bindFunction(DataProcessingService.metricFunctions);
});
}
////////////////
// Templating //
////////////////
/**
* Find metrics from templated request.
*
* @param {string} query Query from Templating
* @return {string} Metric name - group, host, app or item or list
* of metrics in "{metric1,metcic2,...,metricN}" format.
*/
this.metricFindQuery = function (query) {
// Split query. Query structure:
// group.host.app.item
var parts = [];
_.each(query.split('.'), function (part) {
part = templateSrv.replace(part);
// Replace wildcard to regex
if (part === '*') {
part = '/.*/';
}
parts.push(part);
});
var template = _.object(['group', 'host', 'app', 'item'], parts);
// Get items
if (parts.length === 4) {
return this.queryProcessor.filterItems(template.group, template.host,
template.app, 'all', true)
.then(function(items) {
return _.map(items, formatMetric);
});
}
// Get applications
else if (parts.length === 3) {
return this.queryProcessor.filterApplications(template.group, template.host)
.then(function(apps) {
return _.map(apps, formatMetric);
});
}
// Get hosts
else if (parts.length === 2) {
return this.queryProcessor.filterHosts(template.group)
.then(function(hosts) {
return _.map(hosts, formatMetric);
});
}
// Get groups
else if (parts.length === 1) {
return this.zabbixCache.getGroups(template.group).then(function(groups) {
return _.map(groups, formatMetric);
});
}
// Return empty object for invalid request
else {
return $q.when([]);
}
};
function formatMetric(metricObj) {
return {
text: metricObj.name,
expandable: false
};
}
/////////////////
// Annotations //
/////////////////
this.annotationQuery = function(options) {
var from = Math.ceil(dateMath.parse(options.rangeRaw.from) / 1000);
var to = Math.ceil(dateMath.parse(options.rangeRaw.to) / 1000);
var annotation = options.annotation;
var self = this;
var showEvents = annotation.showOkEvents ? [0, 1] : 1;
var buildQuery = self.queryProcessor.buildTriggerQuery(templateSrv.replace(annotation.group),
templateSrv.replace(annotation.host),
templateSrv.replace(annotation.application));
return buildQuery.then(function(query) {
return self.zabbixAPI.getTriggers(query.groupids,
query.hostids,
query.applicationids,
showEvents)
.then(function(triggers) {
// Filter triggers by description
if (utils.isRegex(annotation.trigger)) {
triggers = _.filter(triggers, function(trigger) {
return utils.buildRegex(annotation.trigger).test(trigger.description);
});
} else if (annotation.trigger) {
triggers = _.filter(triggers, function(trigger) {
return trigger.description === annotation.trigger;
});
}
// Remove events below the chose severity
triggers = _.filter(triggers, function(trigger) {
return Number(trigger.priority) >= Number(annotation.minseverity);
});
var objectids = _.map(triggers, 'triggerid');
var params = {
output: 'extend',
time_from: from,
time_till: to,
objectids: objectids,
select_acknowledges: 'extend',
selectHosts: 'extend',
value: showEvents
};
return self.zabbixAPI.request('event.get', params)
.then(function (events) {
var indexedTriggers = _.indexBy(triggers, 'triggerid');
// Hide acknowledged events if option enabled
if (annotation.hideAcknowledged) {
events = _.filter(events, function(event) {
return !event.acknowledges.length;
});
}
return _.map(events, function(e) {
var title ='';
if (annotation.showHostname) {
title += e.hosts[0].name + ': ';
}
// Show event type (OK or Problem)
title += Number(e.value) ? 'Problem' : 'OK';
var formatted_acknowledges = utils.formatAcknowledges(e.acknowledges);
return {
annotation: annotation,
time: e.clock * 1000,
title: title,
text: indexedTriggers[e.objectid].description + formatted_acknowledges
};
});
});
});
});
};
}
return ZabbixAPIDatasource;
});

24
plugins/datasource-zabbix/module.js
View File

@@ -1,24 +0,0 @@
define([
'./datasource',
'./queryCtrl'
],
function (ZabbixAPIDatasource, ZabbixQueryCtrl) {
'use strict';
function ZabbixQueryOptionsCtrl() {}
ZabbixQueryOptionsCtrl.templateUrl = 'partials/query.options.html';
function ZabbixAnnotationsQueryCtrl() {}
ZabbixAnnotationsQueryCtrl.templateUrl = 'partials/annotations.editor.html';
function ZabbixConfigCtrl() {}
ZabbixConfigCtrl.templateUrl = 'partials/config.html';
return {
Datasource: ZabbixAPIDatasource,
QueryCtrl: ZabbixQueryCtrl,
ConfigCtrl: ZabbixConfigCtrl,
QueryOptionsCtrl: ZabbixQueryOptionsCtrl,
AnnotationsQueryCtrl: ZabbixAnnotationsQueryCtrl
};
});

0
plugins/datasource-zabbix/addMetricFunction.js → src/datasource-zabbix/addMetricFunction.js
View File

0
plugins/datasource-zabbix/dataProcessingService.js → src/datasource-zabbix/dataProcessingService.js
View File

430
src/datasource-zabbix/datasource.js Normal file
View File

@@ -0,0 +1,430 @@
//import angular from 'angular';
import _ from 'lodash';
import {parse as dateMathParse} from 'app/core/utils/datemath';
import Utils from './utils';
import metricFunctions from './metricFunctions';
import {zabbixHelperSrv} from './helperFunctions';
import {ZabbixAPI} from './zabbixAPI';
import {ZabbixCachingProxy} from './zabbixCache';
import {QueryProcessor} from './queryProcessor';
import {DataProcessingService} from './dataProcessingService';
export class ZabbixAPIDatasource {
constructor(instanceSettings, $q, templateSrv, alertSrv, ZabbixAPI, ZabbixCachingProxy, QueryProcessor, zabbixHelperSrv, DataProcessingService) {
// General data source settings
this.name = instanceSettings.name;
this.url = instanceSettings.url;
this.basicAuth = instanceSettings.basicAuth;
this.withCredentials = instanceSettings.withCredentials;
// Zabbix API credentials
this.username = instanceSettings.jsonData.username;
this.password = instanceSettings.jsonData.password;
// Use trends instead history since specified time
this.trends = instanceSettings.jsonData.trends;
this.trendsFrom = instanceSettings.jsonData.trendsFrom || '7d';
// Set cache update interval
var ttl = instanceSettings.jsonData.cacheTTL || '1h';
this.cacheTTL = Utils.parseInterval(ttl);
// Initialize Zabbix API
this.zabbixAPI = new ZabbixAPI(this.url, this.username, this.password, this.basicAuth, this.withCredentials);
// Initialize cache service
this.zabbixCache = new ZabbixCachingProxy(this.zabbixAPI, this.cacheTTL);
// Initialize query builder
this.queryProcessor = new QueryProcessor(this.zabbixCache);
// Dependencies
this.q = $q;
this.templateSrv = templateSrv;
this.alertSrv = alertSrv;
this.zabbixHelperSrv = zabbixHelperSrv;
this.DataProcessingService = DataProcessingService;
console.log(this.zabbixCache);
}
////////////////////////
// Datasource methods //
////////////////////////
/**
* Test connection to Zabbix API
* @return {object} Connection status and Zabbix API version
*/
testDatasource() {
var self = this;
return this.zabbixAPI.getVersion().then(function (version) {
return self.zabbixAPI.login().then(function (auth) {
if (auth) {
return {
status: "success",
title: "Success",
message: "Zabbix API version: " + version
};
} else {
return {
status: "error",
title: "Invalid user name or password",
message: "Zabbix API version: " + version
};
}
}, function(error) {
console.log(error);
return {
status: "error",
title: "Connection failed",
message: error
};
});
},
function(error) {
console.log(error);
return {
status: "error",
title: "Connection failed",
message: "Could not connect to given url"
};
});
}
/**
* Query panel data. Calls for each panel in dashboard.
* @param {Object} options Contains time range, targets and other info.
* @return {Object} Grafana metrics object with timeseries data for each target.
*/
query(options) {
var self = this;
// get from & to in seconds
var from = Math.ceil(dateMathParse(options.range.from) / 1000);
var to = Math.ceil(dateMathParse(options.range.to) / 1000);
var useTrendsFrom = Math.ceil(dateMathParse('now-' + this.trendsFrom) / 1000);
// Create request for each target
var promises = _.map(options.targets, function(target) {
if (target.mode !== 1) {
// Don't request undefined and hidden targets
if (target.hide || !target.group ||
!target.host || !target.item) {
return [];
}
// Replace templated variables
var groupFilter = this.templateSrv.replace(target.group.filter, options.scopedVars);
var hostFilter = this.templateSrv.replace(target.host.filter, options.scopedVars);
var appFilter = this.templateSrv.replace(target.application.filter, options.scopedVars);
var itemFilter = this.templateSrv.replace(target.item.filter, options.scopedVars);
// Query numeric data
if (!target.mode || target.mode === 0) {
// Build query in asynchronous manner
return self.queryProcessor.build(groupFilter, hostFilter, appFilter, itemFilter)
.then(function(items) {
// Add hostname for items from multiple hosts
var addHostName = target.host.isRegex;
var getHistory;
// Use trends
if ((from < useTrendsFrom) && self.trends) {
// Find trendValue() function and get specified trend value
var trendFunctions = _.map(metricFunctions.getCategories()['Trends'], 'name');
var trendValueFunc = _.find(target.functions, function(func) {
return _.contains(trendFunctions, func.def.name);
});
var valueType = trendValueFunc ? trendValueFunc.params[0] : "avg";
getHistory = self.zabbixAPI.getTrend(items, from, to).then(function(history) {
return self.queryProcessor.handleTrends(history, addHostName, valueType);
});
} else {
// Use history
getHistory = self.zabbixCache.getHistory(items, from, to).then(function(history) {
return self.queryProcessor.handleHistory(history, addHostName);
});
}
return getHistory.then(function (timeseries_data) {
timeseries_data = _.map(timeseries_data, function (timeseries) {
// Filter only transform functions
var transformFunctions = bindFunctionDefs(target.functions, 'Transform', self.DataProcessingService);
// Metric data processing
var dp = timeseries.datapoints;
for (var i = 0; i < transformFunctions.length; i++) {
dp = transformFunctions[i](dp);
}
timeseries.datapoints = dp;
return timeseries;
});
// Aggregations
var aggregationFunctions = bindFunctionDefs(target.functions, 'Aggregate', self.DataProcessingService);
var dp = _.map(timeseries_data, 'datapoints');
if (aggregationFunctions.length) {
for (var i = 0; i < aggregationFunctions.length; i++) {
dp = aggregationFunctions[i](dp);
}
var lastAgg = _.findLast(target.functions, function(func) {
return _.contains(
_.map(metricFunctions.getCategories()['Aggregate'], 'name'), func.def.name);
});
timeseries_data = [{
target: lastAgg.text,
datapoints: dp
}];
}
// Apply alias functions
var aliasFunctions = bindFunctionDefs(target.functions, 'Alias', self.DataProcessingService);
for (var j = 0; j < aliasFunctions.length; j++) {
_.each(timeseries_data, aliasFunctions[j]);
}
return timeseries_data;
});
});
}
// Query text data
else if (target.mode === 2) {
return self.queryProcessor.build(groupFilter, hostFilter, appFilter, itemFilter)
.then(function(items) {
var deferred = self.q.defer();
if (items.length) {
self.zabbixAPI.getLastValue(items[0].itemid).then(function(lastvalue) {
if (target.textFilter) {
var text_extract_pattern = new RegExp(self.templateSrv.replace(target.textFilter, options.scopedVars));
var result = text_extract_pattern.exec(lastvalue);
if (result) {
if (target.useCaptureGroups) {
result = result[1];
} else {
result = result[0];
}
}
deferred.resolve(result);
} else {
deferred.resolve(lastvalue);
}
});
} else {
deferred.resolve(null);
}
return deferred.promise.then(function(text) {
return {
target: target.item.name,
datapoints: [[text, to * 1000]]
};
});
});
}
}
// IT services mode
else if (target.mode === 1) {
// Don't show undefined and hidden targets
if (target.hide || !target.itservice || !target.slaProperty) {
return [];
} else {
return this.zabbixAPI.getSLA(target.itservice.serviceid, from, to)
.then(_.bind(zabbixHelperSrv.handleSLAResponse, zabbixHelperSrv, target.itservice, target.slaProperty));
}
}
}, this);
var self = this;
// Data for panel (all targets)
return this.q.all(_.flatten(promises))
.then(_.flatten)
.then(function (timeseries_data) {
// Series downsampling
var data = _.map(timeseries_data, function(timeseries) {
var DPS = self.DataProcessingService;
if (timeseries.datapoints.length > options.maxDataPoints) {
timeseries.datapoints = DPS.groupBy(options.interval, DPS.AVERAGE, timeseries.datapoints);
}
return timeseries;
});
return { data: data };
});
}
////////////////
// Templating //
////////////////
/**
* Find metrics from templated request.
*
* @param {string} query Query from Templating
* @return {string} Metric name - group, host, app or item or list
* of metrics in "{metric1,metcic2,...,metricN}" format.
*/
metricFindQuery(query) {
// Split query. Query structure:
// group.host.app.item
var parts = [];
_.each(query.split('.'), function (part) {
part = this.templateSrv.replace(part);
// Replace wildcard to regex
if (part === '*') {
part = '/.*/';
}
parts.push(part);
});
var template = _.object(['group', 'host', 'app', 'item'], parts);
// Get items
if (parts.length === 4) {
return this.queryProcessor.filterItems(template.group, template.host,
template.app, 'all', true)
.then(function(items) {
return _.map(items, formatMetric);
});
}
// Get applications
else if (parts.length === 3) {
return this.queryProcessor.filterApplications(template.group, template.host)
.then(function(apps) {
return _.map(apps, formatMetric);
});
}
// Get hosts
else if (parts.length === 2) {
return this.queryProcessor.filterHosts(template.group)
.then(function(hosts) {
return _.map(hosts, formatMetric);
});
}
// Get groups
else if (parts.length === 1) {
return this.zabbixCache.getGroups(template.group).then(function(groups) {
return _.map(groups, formatMetric);
});
}
// Return empty object for invalid request
else {
return this.q.when([]);
}
}
/////////////////
// Annotations //
/////////////////
annotationQuery(options) {
var from = Math.ceil(dateMathParse(options.rangeRaw.from) / 1000);
var to = Math.ceil(dateMathParse(options.rangeRaw.to) / 1000);
var annotation = options.annotation;
var self = this;
var showEvents = annotation.showOkEvents ? [0, 1] : 1;
var buildQuery = self.queryProcessor.buildTriggerQuery(this.templateSrv.replace(annotation.group),
this.templateSrv.replace(annotation.host),
this.templateSrv.replace(annotation.application));
return buildQuery.then(function(query) {
return self.zabbixAPI.getTriggers(query.groupids,
query.hostids,
query.applicationids,
showEvents)
.then(function(triggers) {
// Filter triggers by description
if (Utils.isRegex(annotation.trigger)) {
triggers = _.filter(triggers, function(trigger) {
return Utils.buildRegex(annotation.trigger).test(trigger.description);
});
} else if (annotation.trigger) {
triggers = _.filter(triggers, function(trigger) {
return trigger.description === annotation.trigger;
});
}
// Remove events below the chose severity
triggers = _.filter(triggers, function(trigger) {
return Number(trigger.priority) >= Number(annotation.minseverity);
});
var objectids = _.map(triggers, 'triggerid');
var params = {
output: 'extend',
time_from: from,
time_till: to,
objectids: objectids,
select_acknowledges: 'extend',
selectHosts: 'extend',
value: showEvents
};
return self.zabbixAPI.request('event.get', params)
.then(function (events) {
var indexedTriggers = _.indexBy(triggers, 'triggerid');
// Hide acknowledged events if option enabled
if (annotation.hideAcknowledged) {
events = _.filter(events, function(event) {
return !event.acknowledges.length;
});
}
return _.map(events, function(e) {
var title ='';
if (annotation.showHostname) {
title += e.hosts[0].name + ': ';
}
// Show event type (OK or Problem)
title += Number(e.value) ? 'Problem' : 'OK';
var formatted_acknowledges = Utils.formatAcknowledges(e.acknowledges);
return {
annotation: annotation,
time: e.clock * 1000,
title: title,
text: indexedTriggers[e.objectid].description + formatted_acknowledges
};
});
});
});
});
}
}
function bindFunctionDefs(functionDefs, category, DataProcessingService) {
'use strict';
var aggregationFunctions = _.map(metricFunctions.getCategories()[category], 'name');
var aggFuncDefs = _.filter(functionDefs, function(func) {
return _.contains(aggregationFunctions, func.def.name);
});
return _.map(aggFuncDefs, function(func) {
var funcInstance = metricFunctions.createFuncInstance(func.def, func.params);
return funcInstance.bindFunction(DataProcessingService.metricFunctions);
});
}
function formatMetric(metricObj) {
'use strict';
return {
text: metricObj.name,
expandable: false
};
}

0
plugins/datasource-zabbix/directives.js → src/datasource-zabbix/directives.js
View File

0
plugins/datasource-zabbix/helperFunctions.js → src/datasource-zabbix/helperFunctions.js
View File

0
plugins/datasource-zabbix/metricFunctionEditor.js → src/datasource-zabbix/metricFunctionEditor.js
View File

0
plugins/datasource-zabbix/metricFunctions.js → src/datasource-zabbix/metricFunctions.js
View File

19
src/datasource-zabbix/module.js Normal file
View File

@@ -0,0 +1,19 @@
import {ZabbixAPIDatasource} from './datasource';
import {ZabbixQueryCtrl} from './queryCtrl';
class ZabbixConfigCtrl {}
ZabbixConfigCtrl.templateUrl = 'partials/config.html';
class ZabbixQueryOptionsCtrl {}
ZabbixQueryOptionsCtrl.templateUrl = 'partials/query.options.html';
class ZabbixAnnotationsQueryCtrl {}
ZabbixAnnotationsQueryCtrl.templateUrl = 'partials/annotations.editor.html';
export {
ZabbixAPIDatasource as Datasource,
ZabbixQueryCtrl as QueryCtrl,
ZabbixConfigCtrl as ConfigCtrl,
ZabbixQueryOptionsCtrl as QueryOptionsCtrl,
ZabbixAnnotationsQueryCtrl as AnnotationsQueryCtrl
};

0
plugins/datasource-zabbix/partials/annotations.editor.html → src/datasource-zabbix/partials/annotations.editor.html
View File

0
plugins/datasource-zabbix/partials/config.html → src/datasource-zabbix/partials/config.html
View File

0
plugins/datasource-zabbix/partials/query.editor.html → src/datasource-zabbix/partials/query.editor.html
View File

0
plugins/datasource-zabbix/partials/query.options.html → src/datasource-zabbix/partials/query.options.html
View File

0
plugins/datasource-zabbix/plugin.json → src/datasource-zabbix/plugin.json
View File

0
plugins/datasource-zabbix/queryCtrl.js → src/datasource-zabbix/queryCtrl.js
View File

0
plugins/datasource-zabbix/queryProcessor.js → src/datasource-zabbix/queryProcessor.js
View File

0
plugins/datasource-zabbix/utils.js → src/datasource-zabbix/utils.js
View File

0
plugins/datasource-zabbix/zabbixAPI.js → src/datasource-zabbix/zabbixAPI.js
View File

0
plugins/datasource-zabbix/zabbixAPIService.js → src/datasource-zabbix/zabbixAPIService.js
View File

0
plugins/datasource-zabbix/zabbixCache.js → src/datasource-zabbix/zabbixCache.js
View File

0
plugins/panel-triggers/editor.html → src/panel-triggers/editor.html
View File

0
plugins/panel-triggers/editor.js → src/panel-triggers/editor.js
View File

0
plugins/panel-triggers/module.html → src/panel-triggers/module.html
View File

0
plugins/panel-triggers/module.js → src/panel-triggers/module.js
View File

0
plugins/panel-triggers/plugin.json → src/panel-triggers/plugin.json
View File

0
plugins/panel-triggers/trigger.colorpicker.html → src/panel-triggers/trigger.colorpicker.html
View File