diff --git a/dist/datasource-zabbix/datasource.js b/dist/datasource-zabbix/datasource.js new file mode 100644 index 0000000..c7b9925 --- /dev/null +++ b/dist/datasource-zabbix/datasource.js @@ -0,0 +1,808 @@ +'use strict'; + +System.register(['lodash', 'app/core/utils/datemath', './utils', './migrations', './metricFunctions', './constants', './dataProcessor', './responseHandler', './zabbixAlerting.service.js', './zabbix/zabbix', './zabbix/connectors/zabbix_api/zabbixAPICore'], function (_export, _context) { + "use strict"; + + var _, dateMath, utils, migrations, metricFunctions, c, dataProcessor, responseHandler, Zabbix, ZabbixAPIError, _slicedToArray, _createClass, ZabbixAPIDatasource; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function bindFunctionDefs(functionDefs, category) { + var aggregationFunctions = _.map(metricFunctions.getCategories()[category], 'name'); + var aggFuncDefs = _.filter(functionDefs, function (func) { + return _.includes(aggregationFunctions, func.def.name); + }); + + return _.map(aggFuncDefs, function (func) { + var funcInstance = metricFunctions.createFuncInstance(func.def, func.params); + return funcInstance.bindFunction(dataProcessor.metricFunctions); + }); + } + + function getConsolidateBy(target) { + var consolidateBy = void 0; + var funcDef = _.find(target.functions, function (func) { + return func.def.name === 'consolidateBy'; + }); + if (funcDef && funcDef.params && funcDef.params.length) { + consolidateBy = funcDef.params[0]; + } + return consolidateBy; + } + + function downsampleSeries(timeseries_data, options) { + var defaultAgg = dataProcessor.aggregationFunctions['avg']; + var consolidateByFunc = dataProcessor.aggregationFunctions[options.consolidateBy] || defaultAgg; + return _.map(timeseries_data, function (timeseries) { + if (timeseries.datapoints.length > options.maxDataPoints) { + timeseries.datapoints = dataProcessor.groupBy(options.interval, consolidateByFunc, timeseries.datapoints); + } + return timeseries; + }); + } + + function formatMetric(metricObj) { + return { + text: metricObj.name, + expandable: false + }; + } + + /** + * Custom formatter for template variables. + * Default Grafana "regex" formatter returns + * value1|value2 + * This formatter returns + * (value1|value2) + * This format needed for using in complex regex with + * template variables, for example + * /CPU $cpu_item.*time/ where $cpu_item is system,user,iowait + */ + function zabbixTemplateFormat(value) { + if (typeof value === 'string') { + return utils.escapeRegex(value); + } + + var escapedValues = _.map(value, utils.escapeRegex); + return '(' + escapedValues.join('|') + ')'; + } + + function zabbixItemIdsTemplateFormat(value) { + if (typeof value === 'string') { + return value; + } + return value.join(','); + } + + /** + * If template variables are used in request, replace it using regex format + * and wrap with '/' for proper multi-value work. Example: + * $variable selected as a, b, c + * We use filter $variable + * $variable -> a|b|c -> /a|b|c/ + * /$variable/ -> /a|b|c/ -> /a|b|c/ + */ + function replaceTemplateVars(templateSrv, target, scopedVars) { + var replacedTarget = templateSrv.replace(target, scopedVars, zabbixTemplateFormat); + if (target !== replacedTarget && !utils.isRegex(replacedTarget)) { + replacedTarget = '/^' + replacedTarget + '$/'; + } + return replacedTarget; + } + + // Apply function one by one: + // sequence([a(), b(), c()]) = c(b(a())); + function sequence(funcsArray) { + return function (result) { + for (var i = 0; i < funcsArray.length; i++) { + result = funcsArray[i].call(this, result); + } + return result; + }; + } + + function filterEnabledTargets(targets) { + return _.filter(targets, function (target) { + return !(target.hide || !target.group || !target.host || !target.item); + }); + } + + function getTriggerThreshold(expression) { + var thresholdPattern = /.*[<>=]{1,2}([\d\.]+)/; + var finded_thresholds = expression.match(thresholdPattern); + if (finded_thresholds && finded_thresholds.length >= 2) { + var threshold = finded_thresholds[1]; + threshold = Number(threshold); + return threshold; + } else { + return null; + } + } + + return { + setters: [function (_lodash) { + _ = _lodash.default; + }, function (_appCoreUtilsDatemath) { + dateMath = _appCoreUtilsDatemath; + }, function (_utils) { + utils = _utils; + }, function (_migrations) { + migrations = _migrations; + }, function (_metricFunctions) { + metricFunctions = _metricFunctions; + }, function (_constants) { + c = _constants; + }, function (_dataProcessor) { + dataProcessor = _dataProcessor.default; + }, function (_responseHandler) { + responseHandler = _responseHandler.default; + }, function (_zabbixAlertingServiceJs) {}, function (_zabbixZabbix) { + Zabbix = _zabbixZabbix.Zabbix; + }, function (_zabbixConnectorsZabbix_apiZabbixAPICore) { + ZabbixAPIError = _zabbixConnectorsZabbix_apiZabbixAPICore.ZabbixAPIError; + }], + execute: function () { + _slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + }(); + + _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + _export('ZabbixAPIDatasource', ZabbixAPIDatasource = function () { + + /** @ngInject */ + function ZabbixAPIDatasource(instanceSettings, templateSrv, alertSrv, dashboardSrv, backendSrv, datasourceSrv, zabbixAlertingSrv) { + _classCallCheck(this, ZabbixAPIDatasource); + + this.templateSrv = templateSrv; + this.alertSrv = alertSrv; + this.dashboardSrv = dashboardSrv; + this.zabbixAlertingSrv = zabbixAlertingSrv; + + // Use custom format for template variables + this.replaceTemplateVars = _.partial(replaceTemplateVars, this.templateSrv); + + // General data source settings + this.name = instanceSettings.name; + this.url = instanceSettings.url; + this.basicAuth = instanceSettings.basicAuth; + this.withCredentials = instanceSettings.withCredentials; + + var jsonData = instanceSettings.jsonData || {}; + + // Zabbix API credentials + this.username = jsonData.username; + this.password = jsonData.password; + + // Use trends instead history since specified time + this.trends = jsonData.trends; + this.trendsFrom = jsonData.trendsFrom || '7d'; + this.trendsRange = jsonData.trendsRange || '4d'; + + // Set cache update interval + var ttl = jsonData.cacheTTL || '1h'; + this.cacheTTL = utils.parseInterval(ttl); + + // Alerting options + this.alertingEnabled = jsonData.alerting; + this.addThresholds = jsonData.addThresholds; + this.alertingMinSeverity = jsonData.alertingMinSeverity || c.SEV_WARNING; + + // Other options + this.disableReadOnlyUsersAck = jsonData.disableReadOnlyUsersAck; + + // Direct DB Connection options + var dbConnectionOptions = jsonData.dbConnection || {}; + this.enableDirectDBConnection = dbConnectionOptions.enable; + this.datasourceId = dbConnectionOptions.datasourceId; + + var zabbixOptions = { + url: this.url, + username: this.username, + password: this.password, + basicAuth: this.basicAuth, + withCredentials: this.withCredentials, + cacheTTL: this.cacheTTL, + enableDirectDBConnection: this.enableDirectDBConnection, + datasourceId: this.datasourceId + }; + + this.zabbix = new Zabbix(zabbixOptions, backendSrv, datasourceSrv); + } + + //////////////////////// + // Datasource methods // + //////////////////////// + + /** + * 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. + */ + + + _createClass(ZabbixAPIDatasource, [{ + key: 'query', + value: function query(options) { + var _this = this; + + // Get alerts for current panel + if (this.alertingEnabled) { + this.alertQuery(options).then(function (alert) { + _this.zabbixAlertingSrv.setPanelAlertState(options.panelId, alert.state); + + _this.zabbixAlertingSrv.removeZabbixThreshold(options.panelId); + if (_this.addThresholds) { + _.forEach(alert.thresholds, function (threshold) { + _this.zabbixAlertingSrv.setPanelThreshold(options.panelId, threshold); + }); + } + }); + } + + // Create request for each target + var promises = _.map(options.targets, function (t) { + // Don't request undefined and hidden targets + if (t.hide) { + return []; + } + + var timeFrom = Math.ceil(dateMath.parse(options.range.from) / 1000); + var timeTo = Math.ceil(dateMath.parse(options.range.to) / 1000); + + // Prevent changes of original object + var target = _.cloneDeep(t); + _this.replaceTargetVariables(target, options); + + // Apply Time-related functions (timeShift(), etc) + var timeFunctions = bindFunctionDefs(target.functions, 'Time'); + if (timeFunctions.length) { + var _sequence = sequence(timeFunctions)([timeFrom, timeTo]), + _sequence2 = _slicedToArray(_sequence, 2), + time_from = _sequence2[0], + time_to = _sequence2[1]; + + timeFrom = time_from; + timeTo = time_to; + } + var timeRange = [timeFrom, timeTo]; + + var useTrends = _this.isUseTrends(timeRange); + + // Metrics or Text query mode + if (!target.mode || target.mode === c.MODE_METRICS || target.mode === c.MODE_TEXT) { + // Migrate old targets + target = migrations.migrate(target); + + // Don't request undefined and hidden targets + if (target.hide || !target.group || !target.host || !target.item) { + return []; + } + + if (!target.mode || target.mode === c.MODE_METRICS) { + return _this.queryNumericData(target, timeRange, useTrends, options); + } else if (target.mode === c.MODE_TEXT) { + return _this.queryTextData(target, timeRange); + } + } else if (target.mode === c.MODE_ITEMID) { + // Item ID mode + if (!target.itemids) { + return []; + } + return _this.queryItemIdData(target, timeRange, useTrends, options); + } else if (target.mode === c.MODE_ITSERVICE) { + // IT services mode + return _this.queryITServiceData(target, timeRange, options); + } else if (target.mode === c.MODE_TRIGGERS) { + // Triggers mode + return _this.queryTriggersData(target, timeRange); + } else { + return []; + } + }); + + // Data for panel (all targets) + return Promise.all(_.flatten(promises)).then(_.flatten).then(function (data) { + return { data: data }; + }); + } + }, { + key: 'queryNumericData', + value: function queryNumericData(target, timeRange, useTrends, options) { + var _this2 = this; + + var getItemOptions = { + itemtype: 'num' + }; + return this.zabbix.getItemsFromTarget(target, getItemOptions).then(function (items) { + return _this2.queryNumericDataForItems(items, target, timeRange, useTrends, options); + }); + } + }, { + key: 'queryNumericDataForItems', + value: function queryNumericDataForItems(items, target, timeRange, useTrends, options) { + var _this3 = this; + + var getHistoryPromise = void 0; + options.valueType = this.getTrendValueType(target); + options.consolidateBy = getConsolidateBy(target) || options.valueType; + + if (useTrends) { + getHistoryPromise = this.zabbix.getTrends(items, timeRange, options); + } else { + getHistoryPromise = this.zabbix.getHistoryTS(items, timeRange, options); + } + + return getHistoryPromise.then(function (timeseries) { + return _this3.applyDataProcessingFunctions(timeseries, target); + }).then(function (timeseries) { + return downsampleSeries(timeseries, options); + }); + } + }, { + key: 'getTrendValueType', + value: function getTrendValueType(target) { + // Find trendValue() function and get specified trend value + var trendFunctions = _.map(metricFunctions.getCategories()['Trends'], 'name'); + var trendValueFunc = _.find(target.functions, function (func) { + return _.includes(trendFunctions, func.def.name); + }); + return trendValueFunc ? trendValueFunc.params[0] : "avg"; + } + }, { + key: 'applyDataProcessingFunctions', + value: function applyDataProcessingFunctions(timeseries_data, target) { + var transformFunctions = bindFunctionDefs(target.functions, 'Transform'); + var aggregationFunctions = bindFunctionDefs(target.functions, 'Aggregate'); + var filterFunctions = bindFunctionDefs(target.functions, 'Filter'); + var aliasFunctions = bindFunctionDefs(target.functions, 'Alias'); + + // Apply transformation functions + timeseries_data = _.cloneDeep(_.map(timeseries_data, function (timeseries) { + timeseries.datapoints = sequence(transformFunctions)(timeseries.datapoints); + return timeseries; + })); + + // Apply filter functions + if (filterFunctions.length) { + timeseries_data = sequence(filterFunctions)(timeseries_data); + } + + // Apply aggregations + if (aggregationFunctions.length) { + var dp = _.map(timeseries_data, 'datapoints'); + dp = sequence(aggregationFunctions)(dp); + + var aggFuncNames = _.map(metricFunctions.getCategories()['Aggregate'], 'name'); + var lastAgg = _.findLast(target.functions, function (func) { + return _.includes(aggFuncNames, func.def.name); + }); + + timeseries_data = [{ + target: lastAgg.text, + datapoints: dp + }]; + } + + // Apply alias functions + _.forEach(timeseries_data, sequence(aliasFunctions)); + + // Apply Time-related functions (timeShift(), etc) + // Find timeShift() function and get specified trend value + this.applyTimeShiftFunction(timeseries_data, target); + + return timeseries_data; + } + }, { + key: 'applyTimeShiftFunction', + value: function applyTimeShiftFunction(timeseries_data, target) { + // Find timeShift() function and get specified interval + var timeShiftFunc = _.find(target.functions, function (func) { + return func.def.name === 'timeShift'; + }); + if (timeShiftFunc) { + var shift = timeShiftFunc.params[0]; + _.forEach(timeseries_data, function (series) { + series.datapoints = dataProcessor.unShiftTimeSeries(shift, series.datapoints); + }); + } + } + }, { + key: 'queryTextData', + value: function queryTextData(target, timeRange) { + var _this4 = this; + + var options = { + itemtype: 'text' + }; + return this.zabbix.getItemsFromTarget(target, options).then(function (items) { + return _this4.zabbix.getHistoryText(items, timeRange, target); + }); + } + }, { + key: 'queryItemIdData', + value: function queryItemIdData(target, timeRange, useTrends, options) { + var _this5 = this; + + var itemids = target.itemids; + itemids = this.templateSrv.replace(itemids, options.scopedVars, zabbixItemIdsTemplateFormat); + itemids = _.map(itemids.split(','), function (itemid) { + return itemid.trim(); + }); + + if (!itemids) { + return []; + } + + return this.zabbix.getItemsByIDs(itemids).then(function (items) { + return _this5.queryNumericDataForItems(items, target, timeRange, useTrends, options); + }); + } + }, { + key: 'queryITServiceData', + value: function queryITServiceData(target, timeRange, options) { + var _this6 = this; + + // Don't show undefined and hidden targets + if (target.hide || !target.itservice && !target.itServiceFilter || !target.slaProperty) { + return []; + } + + var itServiceFilter = void 0; + options.isOldVersion = target.itservice && !target.itServiceFilter; + + if (options.isOldVersion) { + // Backward compatibility + itServiceFilter = '/.*/'; + } else { + itServiceFilter = this.replaceTemplateVars(target.itServiceFilter, options.scopedVars); + } + + return this.zabbix.getITServices(itServiceFilter).then(function (itservices) { + return _this6.zabbix.getSLA(itservices, timeRange, target, options); + }); + } + }, { + key: 'queryTriggersData', + value: function queryTriggersData(target, timeRange) { + var _this7 = this; + + var _timeRange = _slicedToArray(timeRange, 2), + timeFrom = _timeRange[0], + timeTo = _timeRange[1]; + + return this.zabbix.getHostsFromTarget(target).then(function (results) { + var _results = _slicedToArray(results, 2), + hosts = _results[0], + apps = _results[1]; + + if (hosts.length) { + var hostids = _.map(hosts, 'hostid'); + var appids = _.map(apps, 'applicationid'); + var options = { + minSeverity: target.triggers.minSeverity, + acknowledged: target.triggers.acknowledged, + count: target.triggers.count, + timeFrom: timeFrom, + timeTo: timeTo + }; + return _this7.zabbix.getHostAlerts(hostids, appids, options).then(function (triggers) { + return responseHandler.handleTriggersResponse(triggers, timeRange); + }); + } else { + return Promise.resolve([]); + } + }); + } + }, { + key: 'testDatasource', + value: function testDatasource() { + var _this8 = this; + + var zabbixVersion = void 0; + return this.zabbix.getVersion().then(function (version) { + zabbixVersion = version; + return _this8.zabbix.login(); + }).then(function () { + if (_this8.enableDirectDBConnection) { + return _this8.zabbix.dbConnector.testDataSource(); + } else { + return Promise.resolve(); + } + }).then(function () { + return { + status: "success", + title: "Success", + message: "Zabbix API version: " + zabbixVersion + }; + }).catch(function (error) { + if (error instanceof ZabbixAPIError) { + return { + status: "error", + title: error.message, + message: error.message + }; + } else if (error.data && error.data.message) { + return { + status: "error", + title: "Connection failed", + message: "Connection failed: " + error.data.message + }; + } else { + return { + status: "error", + title: "Connection failed", + message: "Could not connect to given url" + }; + } + }); + } + }, { + key: 'metricFindQuery', + value: function metricFindQuery(query) { + var _this9 = this; + + var result = void 0; + var parts = []; + + // Split query. Query structure: group.host.app.item + _.each(utils.splitTemplateQuery(query), function (part) { + part = _this9.replaceTemplateVars(part, {}); + + // Replace wildcard to regex + if (part === '*') { + part = '/.*/'; + } + parts.push(part); + }); + var template = _.zipObject(['group', 'host', 'app', 'item'], parts); + + // Get items + if (parts.length === 4) { + // Search for all items, even it's not belong to any application + if (template.app === '/.*/') { + template.app = ''; + } + result = this.zabbix.getItems(template.group, template.host, template.app, template.item); + } else if (parts.length === 3) { + // Get applications + result = this.zabbix.getApps(template.group, template.host, template.app); + } else if (parts.length === 2) { + // Get hosts + result = this.zabbix.getHosts(template.group, template.host); + } else if (parts.length === 1) { + // Get groups + result = this.zabbix.getGroups(template.group); + } else { + result = Promise.resolve([]); + } + + return result.then(function (metrics) { + return _.map(metrics, formatMetric); + }); + } + }, { + key: 'annotationQuery', + value: function annotationQuery(options) { + var _this10 = this; + + var timeFrom = Math.ceil(dateMath.parse(options.rangeRaw.from) / 1000); + var timeTo = Math.ceil(dateMath.parse(options.rangeRaw.to) / 1000); + var annotation = options.annotation; + var showOkEvents = annotation.showOkEvents ? c.SHOW_ALL_EVENTS : c.SHOW_OK_EVENTS; + + // Show all triggers + var triggersOptions = { + showTriggers: c.SHOW_ALL_TRIGGERS, + hideHostsInMaintenance: false + }; + + var getTriggers = this.zabbix.getTriggers(this.replaceTemplateVars(annotation.group, {}), this.replaceTemplateVars(annotation.host, {}), this.replaceTemplateVars(annotation.application, {}), triggersOptions); + + return getTriggers.then(function (triggers) { + + // Filter triggers by description + var triggerName = _this10.replaceTemplateVars(annotation.trigger, {}); + if (utils.isRegex(triggerName)) { + triggers = _.filter(triggers, function (trigger) { + return utils.buildRegex(triggerName).test(trigger.description); + }); + } else if (triggerName) { + triggers = _.filter(triggers, function (trigger) { + return trigger.description === triggerName; + }); + } + + // Remove events below the chose severity + triggers = _.filter(triggers, function (trigger) { + return Number(trigger.priority) >= Number(annotation.minseverity); + }); + + var objectids = _.map(triggers, 'triggerid'); + return _this10.zabbix.getEvents(objectids, timeFrom, timeTo, showOkEvents).then(function (events) { + var indexedTriggers = _.keyBy(triggers, 'triggerid'); + + // Hide acknowledged events if option enabled + if (annotation.hideAcknowledged) { + events = _.filter(events, function (event) { + return !event.acknowledges.length; + }); + } + + return _.map(events, function (event) { + var tags = void 0; + if (annotation.showHostname) { + tags = _.map(event.hosts, 'name'); + } + + // Show event type (OK or Problem) + var title = Number(event.value) ? 'Problem' : 'OK'; + + var formatted_acknowledges = utils.formatAcknowledges(event.acknowledges); + return { + annotation: annotation, + time: event.clock * 1000, + title: title, + tags: tags, + text: indexedTriggers[event.objectid].description + formatted_acknowledges + }; + }); + }); + }); + } + }, { + key: 'alertQuery', + value: function alertQuery(options) { + var _this11 = this; + + var enabled_targets = filterEnabledTargets(options.targets); + var getPanelItems = _.map(enabled_targets, function (t) { + var target = _.cloneDeep(t); + _this11.replaceTargetVariables(target, options); + return _this11.zabbix.getItemsFromTarget(target, { itemtype: 'num' }); + }); + + return Promise.all(getPanelItems).then(function (results) { + var items = _.flatten(results); + var itemids = _.map(items, 'itemid'); + + if (itemids.length === 0) { + return []; + } + return _this11.zabbix.getAlerts(itemids); + }).then(function (triggers) { + triggers = _.filter(triggers, function (trigger) { + return trigger.priority >= _this11.alertingMinSeverity; + }); + + if (!triggers || triggers.length === 0) { + return {}; + } + + var state = 'ok'; + + var firedTriggers = _.filter(triggers, { value: '1' }); + if (firedTriggers.length) { + state = 'alerting'; + } + + var thresholds = _.map(triggers, function (trigger) { + return getTriggerThreshold(trigger.expression); + }); + + return { + panelId: options.panelId, + state: state, + thresholds: thresholds + }; + }); + } + }, { + key: 'replaceTargetVariables', + value: function replaceTargetVariables(target, options) { + var _this12 = this; + + var parts = ['group', 'host', 'application', 'item']; + _.forEach(parts, function (p) { + if (target[p] && target[p].filter) { + target[p].filter = _this12.replaceTemplateVars(target[p].filter, options.scopedVars); + } + }); + target.textFilter = this.replaceTemplateVars(target.textFilter, options.scopedVars); + + _.forEach(target.functions, function (func) { + func.params = _.map(func.params, function (param) { + if (typeof param === 'number') { + return +_this12.templateSrv.replace(param.toString(), options.scopedVars); + } else { + return _this12.templateSrv.replace(param, options.scopedVars); + } + }); + }); + } + }, { + key: 'isUseTrends', + value: function isUseTrends(timeRange) { + var _timeRange2 = _slicedToArray(timeRange, 2), + timeFrom = _timeRange2[0], + timeTo = _timeRange2[1]; + + var useTrendsFrom = Math.ceil(dateMath.parse('now-' + this.trendsFrom) / 1000); + var useTrendsRange = Math.ceil(utils.parseInterval(this.trendsRange) / 1000); + var useTrends = this.trends && (timeFrom <= useTrendsFrom || timeTo - timeFrom >= useTrendsRange); + return useTrends; + } + }]); + + return ZabbixAPIDatasource; + }()); + + _export('ZabbixAPIDatasource', ZabbixAPIDatasource); + + _export('zabbixTemplateFormat', zabbixTemplateFormat); + + // Fix for backward compatibility with lodash 2.4 + if (!_.includes) { + _.includes = _.contains; + } + if (!_.keyBy) { + _.keyBy = _.indexBy; + } + } + }; +}); +//# sourceMappingURL=datasource.js.map diff --git a/dist/datasource-zabbix/datasource.js.map b/dist/datasource-zabbix/datasource.js.map new file mode 100644 index 0000000..91d29b2 --- /dev/null +++ b/dist/datasource-zabbix/datasource.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../src/datasource-zabbix/datasource.js"],"names":["bindFunctionDefs","functionDefs","category","aggregationFunctions","_","map","metricFunctions","getCategories","aggFuncDefs","filter","func","includes","def","name","funcInstance","createFuncInstance","params","bindFunction","dataProcessor","getConsolidateBy","target","consolidateBy","funcDef","find","functions","length","downsampleSeries","timeseries_data","options","defaultAgg","consolidateByFunc","timeseries","datapoints","maxDataPoints","groupBy","interval","formatMetric","metricObj","text","expandable","zabbixTemplateFormat","value","utils","escapeRegex","escapedValues","join","zabbixItemIdsTemplateFormat","replaceTemplateVars","templateSrv","scopedVars","replacedTarget","replace","isRegex","sequence","funcsArray","result","i","call","filterEnabledTargets","targets","hide","group","host","item","getTriggerThreshold","expression","thresholdPattern","finded_thresholds","match","threshold","Number","dateMath","migrations","c","responseHandler","Zabbix","ZabbixAPIError","ZabbixAPIDatasource","instanceSettings","alertSrv","dashboardSrv","backendSrv","datasourceSrv","zabbixAlertingSrv","partial","url","basicAuth","withCredentials","jsonData","username","password","trends","trendsFrom","trendsRange","ttl","cacheTTL","parseInterval","alertingEnabled","alerting","addThresholds","alertingMinSeverity","SEV_WARNING","disableReadOnlyUsersAck","dbConnectionOptions","dbConnection","enableDirectDBConnection","enable","datasourceId","zabbixOptions","zabbix","alertQuery","then","setPanelAlertState","panelId","alert","state","removeZabbixThreshold","forEach","thresholds","setPanelThreshold","promises","t","timeFrom","Math","ceil","parse","range","from","timeTo","to","cloneDeep","replaceTargetVariables","timeFunctions","time_from","time_to","timeRange","useTrends","isUseTrends","mode","MODE_METRICS","MODE_TEXT","migrate","queryNumericData","queryTextData","MODE_ITEMID","itemids","queryItemIdData","MODE_ITSERVICE","queryITServiceData","MODE_TRIGGERS","queryTriggersData","Promise","all","flatten","data","getItemOptions","itemtype","getItemsFromTarget","queryNumericDataForItems","items","getHistoryPromise","valueType","getTrendValueType","getTrends","getHistoryTS","applyDataProcessingFunctions","trendFunctions","trendValueFunc","transformFunctions","filterFunctions","aliasFunctions","dp","aggFuncNames","lastAgg","findLast","applyTimeShiftFunction","timeShiftFunc","shift","series","unShiftTimeSeries","getHistoryText","split","itemid","trim","getItemsByIDs","itservice","itServiceFilter","slaProperty","isOldVersion","getITServices","getSLA","itservices","getHostsFromTarget","results","hosts","apps","hostids","appids","minSeverity","triggers","acknowledged","count","getHostAlerts","handleTriggersResponse","resolve","zabbixVersion","getVersion","version","login","dbConnector","testDataSource","status","title","message","catch","error","query","parts","each","splitTemplateQuery","part","push","template","zipObject","app","getItems","getApps","getHosts","getGroups","metrics","rangeRaw","annotation","showOkEvents","SHOW_ALL_EVENTS","SHOW_OK_EVENTS","triggersOptions","showTriggers","SHOW_ALL_TRIGGERS","hideHostsInMaintenance","getTriggers","application","triggerName","trigger","buildRegex","test","description","priority","minseverity","objectids","getEvents","indexedTriggers","keyBy","hideAcknowledged","events","event","acknowledges","tags","showHostname","formatted_acknowledges","formatAcknowledges","time","clock","objectid","enabled_targets","getPanelItems","getAlerts","firedTriggers","p","textFilter","param","toString","useTrendsFrom","useTrendsRange","contains","indexBy"],"mappings":"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","file":"datasource.js","sourcesContent":["import _ from 'lodash';\nimport * as dateMath from 'app/core/utils/datemath';\nimport * as utils from './utils';\nimport * as migrations from './migrations';\nimport * as metricFunctions from './metricFunctions';\nimport * as c from './constants';\nimport dataProcessor from './dataProcessor';\nimport responseHandler from './responseHandler';\nimport './zabbixAlerting.service.js';\nimport { Zabbix } from './zabbix/zabbix';\nimport {ZabbixAPIError} from './zabbix/connectors/zabbix_api/zabbixAPICore';\n\nclass ZabbixAPIDatasource {\n\n /** @ngInject */\n constructor(instanceSettings, templateSrv, alertSrv, dashboardSrv, backendSrv, datasourceSrv, zabbixAlertingSrv) {\n this.templateSrv = templateSrv;\n this.alertSrv = alertSrv;\n this.dashboardSrv = dashboardSrv;\n this.zabbixAlertingSrv = zabbixAlertingSrv;\n\n // Use custom format for template variables\n this.replaceTemplateVars = _.partial(replaceTemplateVars, this.templateSrv);\n\n // General data source settings\n this.name = instanceSettings.name;\n this.url = instanceSettings.url;\n this.basicAuth = instanceSettings.basicAuth;\n this.withCredentials = instanceSettings.withCredentials;\n\n const jsonData = instanceSettings.jsonData || {};\n\n // Zabbix API credentials\n this.username = jsonData.username;\n this.password = jsonData.password;\n\n // Use trends instead history since specified time\n this.trends = jsonData.trends;\n this.trendsFrom = jsonData.trendsFrom || '7d';\n this.trendsRange = jsonData.trendsRange || '4d';\n\n // Set cache update interval\n var ttl = jsonData.cacheTTL || '1h';\n this.cacheTTL = utils.parseInterval(ttl);\n\n // Alerting options\n this.alertingEnabled = jsonData.alerting;\n this.addThresholds = jsonData.addThresholds;\n this.alertingMinSeverity = jsonData.alertingMinSeverity || c.SEV_WARNING;\n\n // Other options\n this.disableReadOnlyUsersAck = jsonData.disableReadOnlyUsersAck;\n\n // Direct DB Connection options\n let dbConnectionOptions = jsonData.dbConnection || {};\n this.enableDirectDBConnection = dbConnectionOptions.enable;\n this.datasourceId = dbConnectionOptions.datasourceId;\n\n let zabbixOptions = {\n url: this.url,\n username: this.username,\n password: this.password,\n basicAuth: this.basicAuth,\n withCredentials: this.withCredentials,\n cacheTTL: this.cacheTTL,\n enableDirectDBConnection: this.enableDirectDBConnection,\n datasourceId: this.datasourceId\n };\n\n this.zabbix = new Zabbix(zabbixOptions, backendSrv, datasourceSrv);\n }\n\n ////////////////////////\n // Datasource methods //\n ////////////////////////\n\n /**\n * Query panel data. Calls for each panel in dashboard.\n * @param {Object} options Contains time range, targets and other info.\n * @return {Object} Grafana metrics object with timeseries data for each target.\n */\n query(options) {\n // Get alerts for current panel\n if (this.alertingEnabled) {\n this.alertQuery(options).then(alert => {\n this.zabbixAlertingSrv.setPanelAlertState(options.panelId, alert.state);\n\n this.zabbixAlertingSrv.removeZabbixThreshold(options.panelId);\n if (this.addThresholds) {\n _.forEach(alert.thresholds, threshold => {\n this.zabbixAlertingSrv.setPanelThreshold(options.panelId, threshold);\n });\n }\n });\n }\n\n // Create request for each target\n let promises = _.map(options.targets, t => {\n // Don't request undefined and hidden targets\n if (t.hide) {\n return [];\n }\n\n let timeFrom = Math.ceil(dateMath.parse(options.range.from) / 1000);\n let timeTo = Math.ceil(dateMath.parse(options.range.to) / 1000);\n\n // Prevent changes of original object\n let target = _.cloneDeep(t);\n this.replaceTargetVariables(target, options);\n\n // Apply Time-related functions (timeShift(), etc)\n let timeFunctions = bindFunctionDefs(target.functions, 'Time');\n if (timeFunctions.length) {\n const [time_from, time_to] = sequence(timeFunctions)([timeFrom, timeTo]);\n timeFrom = time_from;\n timeTo = time_to;\n }\n let timeRange = [timeFrom, timeTo];\n\n let useTrends = this.isUseTrends(timeRange);\n\n // Metrics or Text query mode\n if (!target.mode || target.mode === c.MODE_METRICS || target.mode === c.MODE_TEXT) {\n // Migrate old targets\n target = migrations.migrate(target);\n\n // Don't request undefined and hidden targets\n if (target.hide || !target.group || !target.host || !target.item) {\n return [];\n }\n\n if (!target.mode || target.mode === c.MODE_METRICS) {\n return this.queryNumericData(target, timeRange, useTrends, options);\n } else if (target.mode === c.MODE_TEXT) {\n return this.queryTextData(target, timeRange);\n }\n } else if (target.mode === c.MODE_ITEMID) {\n // Item ID mode\n if (!target.itemids) {\n return [];\n }\n return this.queryItemIdData(target, timeRange, useTrends, options);\n } else if (target.mode === c.MODE_ITSERVICE) {\n // IT services mode\n return this.queryITServiceData(target, timeRange, options);\n } else if (target.mode === c.MODE_TRIGGERS) {\n // Triggers mode\n return this.queryTriggersData(target, timeRange);\n } else {\n return [];\n }\n });\n\n // Data for panel (all targets)\n return Promise.all(_.flatten(promises))\n .then(_.flatten)\n .then(data => {\n return { data: data };\n });\n }\n\n /**\n * Query target data for Metrics mode\n */\n queryNumericData(target, timeRange, useTrends, options) {\n let getItemOptions = {\n itemtype: 'num'\n };\n return this.zabbix.getItemsFromTarget(target, getItemOptions)\n .then(items => {\n return this.queryNumericDataForItems(items, target, timeRange, useTrends, options);\n });\n }\n\n /**\n * Query history for numeric items\n */\n queryNumericDataForItems(items, target, timeRange, useTrends, options) {\n let getHistoryPromise;\n options.valueType = this.getTrendValueType(target);\n options.consolidateBy = getConsolidateBy(target) || options.valueType;\n\n if (useTrends) {\n getHistoryPromise = this.zabbix.getTrends(items, timeRange, options);\n } else {\n getHistoryPromise = this.zabbix.getHistoryTS(items, timeRange, options);\n }\n\n return getHistoryPromise\n .then(timeseries => this.applyDataProcessingFunctions(timeseries, target))\n .then(timeseries => downsampleSeries(timeseries, options));\n }\n\n getTrendValueType(target) {\n // Find trendValue() function and get specified trend value\n var trendFunctions = _.map(metricFunctions.getCategories()['Trends'], 'name');\n var trendValueFunc = _.find(target.functions, func => {\n return _.includes(trendFunctions, func.def.name);\n });\n return trendValueFunc ? trendValueFunc.params[0] : \"avg\";\n }\n\n applyDataProcessingFunctions(timeseries_data, target) {\n let transformFunctions = bindFunctionDefs(target.functions, 'Transform');\n let aggregationFunctions = bindFunctionDefs(target.functions, 'Aggregate');\n let filterFunctions = bindFunctionDefs(target.functions, 'Filter');\n let aliasFunctions = bindFunctionDefs(target.functions, 'Alias');\n\n // Apply transformation functions\n timeseries_data = _.cloneDeep(_.map(timeseries_data, timeseries => {\n timeseries.datapoints = sequence(transformFunctions)(timeseries.datapoints);\n return timeseries;\n }));\n\n // Apply filter functions\n if (filterFunctions.length) {\n timeseries_data = sequence(filterFunctions)(timeseries_data);\n }\n\n // Apply aggregations\n if (aggregationFunctions.length) {\n let dp = _.map(timeseries_data, 'datapoints');\n dp = sequence(aggregationFunctions)(dp);\n\n let aggFuncNames = _.map(metricFunctions.getCategories()['Aggregate'], 'name');\n let lastAgg = _.findLast(target.functions, func => {\n return _.includes(aggFuncNames, func.def.name);\n });\n\n timeseries_data = [{\n target: lastAgg.text,\n datapoints: dp\n }];\n }\n\n // Apply alias functions\n _.forEach(timeseries_data, sequence(aliasFunctions));\n\n // Apply Time-related functions (timeShift(), etc)\n // Find timeShift() function and get specified trend value\n this.applyTimeShiftFunction(timeseries_data, target);\n\n return timeseries_data;\n }\n\n applyTimeShiftFunction(timeseries_data, target) {\n // Find timeShift() function and get specified interval\n let timeShiftFunc = _.find(target.functions, (func) => {\n return func.def.name === 'timeShift';\n });\n if (timeShiftFunc) {\n let shift = timeShiftFunc.params[0];\n _.forEach(timeseries_data, (series) => {\n series.datapoints = dataProcessor.unShiftTimeSeries(shift, series.datapoints);\n });\n }\n }\n\n /**\n * Query target data for Text mode\n */\n queryTextData(target, timeRange) {\n let options = {\n itemtype: 'text'\n };\n return this.zabbix.getItemsFromTarget(target, options)\n .then(items => {\n return this.zabbix.getHistoryText(items, timeRange, target);\n });\n }\n\n /**\n * Query target data for Item ID mode\n */\n queryItemIdData(target, timeRange, useTrends, options) {\n let itemids = target.itemids;\n itemids = this.templateSrv.replace(itemids, options.scopedVars, zabbixItemIdsTemplateFormat);\n itemids = _.map(itemids.split(','), itemid => itemid.trim());\n\n if (!itemids) {\n return [];\n }\n\n return this.zabbix.getItemsByIDs(itemids)\n .then(items => {\n return this.queryNumericDataForItems(items, target, timeRange, useTrends, options);\n });\n }\n\n /**\n * Query target data for IT Services mode\n */\n queryITServiceData(target, timeRange, options) {\n // Don't show undefined and hidden targets\n if (target.hide || (!target.itservice && !target.itServiceFilter) || !target.slaProperty) {\n return [];\n }\n\n let itServiceFilter;\n options.isOldVersion = target.itservice && !target.itServiceFilter;\n\n if (options.isOldVersion) {\n // Backward compatibility\n itServiceFilter = '/.*/';\n } else {\n itServiceFilter = this.replaceTemplateVars(target.itServiceFilter, options.scopedVars);\n }\n\n return this.zabbix.getITServices(itServiceFilter)\n .then(itservices => {\n return this.zabbix.getSLA(itservices, timeRange, target, options);\n });\n }\n\n queryTriggersData(target, timeRange) {\n let [timeFrom, timeTo] = timeRange;\n return this.zabbix.getHostsFromTarget(target)\n .then((results) => {\n let [hosts, apps] = results;\n if (hosts.length) {\n let hostids = _.map(hosts, 'hostid');\n let appids = _.map(apps, 'applicationid');\n let options = {\n minSeverity: target.triggers.minSeverity,\n acknowledged: target.triggers.acknowledged,\n count: target.triggers.count,\n timeFrom: timeFrom,\n timeTo: timeTo\n };\n return this.zabbix.getHostAlerts(hostids, appids, options)\n .then((triggers) => {\n return responseHandler.handleTriggersResponse(triggers, timeRange);\n });\n } else {\n return Promise.resolve([]);\n }\n });\n }\n\n /**\n * Test connection to Zabbix API\n * @return {object} Connection status and Zabbix API version\n */\n testDatasource() {\n let zabbixVersion;\n return this.zabbix.getVersion()\n .then(version => {\n zabbixVersion = version;\n return this.zabbix.login();\n })\n .then(() => {\n if (this.enableDirectDBConnection) {\n return this.zabbix.dbConnector.testDataSource();\n } else {\n return Promise.resolve();\n }\n })\n .then(() => {\n return {\n status: \"success\",\n title: \"Success\",\n message: \"Zabbix API version: \" + zabbixVersion\n };\n })\n .catch(error => {\n if (error instanceof ZabbixAPIError) {\n return {\n status: \"error\",\n title: error.message,\n message: error.message\n };\n } else if (error.data && error.data.message) {\n return {\n status: \"error\",\n title: \"Connection failed\",\n message: \"Connection failed: \" + error.data.message\n };\n } else {\n return {\n status: \"error\",\n title: \"Connection failed\",\n message: \"Could not connect to given url\"\n };\n }\n });\n }\n\n ////////////////\n // Templating //\n ////////////////\n\n /**\n * Find metrics from templated request.\n *\n * @param {string} query Query from Templating\n * @return {string} Metric name - group, host, app or item or list\n * of metrics in \"{metric1,metcic2,...,metricN}\" format.\n */\n metricFindQuery(query) {\n let result;\n let parts = [];\n\n // Split query. Query structure: group.host.app.item\n _.each(utils.splitTemplateQuery(query), part => {\n part = this.replaceTemplateVars(part, {});\n\n // Replace wildcard to regex\n if (part === '*') {\n part = '/.*/';\n }\n parts.push(part);\n });\n let template = _.zipObject(['group', 'host', 'app', 'item'], parts);\n\n // Get items\n if (parts.length === 4) {\n // Search for all items, even it's not belong to any application\n if (template.app === '/.*/') {\n template.app = '';\n }\n result = this.zabbix.getItems(template.group, template.host, template.app, template.item);\n } else if (parts.length === 3) {\n // Get applications\n result = this.zabbix.getApps(template.group, template.host, template.app);\n } else if (parts.length === 2) {\n // Get hosts\n result = this.zabbix.getHosts(template.group, template.host);\n } else if (parts.length === 1) {\n // Get groups\n result = this.zabbix.getGroups(template.group);\n } else {\n result = Promise.resolve([]);\n }\n\n return result.then(metrics => {\n return _.map(metrics, formatMetric);\n });\n }\n\n /////////////////\n // Annotations //\n /////////////////\n\n annotationQuery(options) {\n var timeFrom = Math.ceil(dateMath.parse(options.rangeRaw.from) / 1000);\n var timeTo = Math.ceil(dateMath.parse(options.rangeRaw.to) / 1000);\n var annotation = options.annotation;\n var showOkEvents = annotation.showOkEvents ? c.SHOW_ALL_EVENTS : c.SHOW_OK_EVENTS;\n\n // Show all triggers\n let triggersOptions = {\n showTriggers: c.SHOW_ALL_TRIGGERS,\n hideHostsInMaintenance: false\n };\n\n var getTriggers = this.zabbix.getTriggers(this.replaceTemplateVars(annotation.group, {}),\n this.replaceTemplateVars(annotation.host, {}),\n this.replaceTemplateVars(annotation.application, {}),\n triggersOptions);\n\n return getTriggers.then(triggers => {\n\n // Filter triggers by description\n let triggerName = this.replaceTemplateVars(annotation.trigger, {});\n if (utils.isRegex(triggerName)) {\n triggers = _.filter(triggers, trigger => {\n return utils.buildRegex(triggerName).test(trigger.description);\n });\n } else if (triggerName) {\n triggers = _.filter(triggers, trigger => {\n return trigger.description === triggerName;\n });\n }\n\n // Remove events below the chose severity\n triggers = _.filter(triggers, trigger => {\n return Number(trigger.priority) >= Number(annotation.minseverity);\n });\n\n var objectids = _.map(triggers, 'triggerid');\n return this.zabbix\n .getEvents(objectids, timeFrom, timeTo, showOkEvents)\n .then(events => {\n var indexedTriggers = _.keyBy(triggers, 'triggerid');\n\n // Hide acknowledged events if option enabled\n if (annotation.hideAcknowledged) {\n events = _.filter(events, event => {\n return !event.acknowledges.length;\n });\n }\n\n return _.map(events, event => {\n let tags;\n if (annotation.showHostname) {\n tags = _.map(event.hosts, 'name');\n }\n\n // Show event type (OK or Problem)\n let title = Number(event.value) ? 'Problem' : 'OK';\n\n let formatted_acknowledges = utils.formatAcknowledges(event.acknowledges);\n return {\n annotation: annotation,\n time: event.clock * 1000,\n title: title,\n tags: tags,\n text: indexedTriggers[event.objectid].description + formatted_acknowledges\n };\n });\n });\n });\n }\n\n /**\n * Get triggers and its details for panel's targets\n * Returns alert state ('ok' if no fired triggers, or 'alerting' if at least 1 trigger is fired)\n * or empty object if no related triggers are finded.\n */\n alertQuery(options) {\n let enabled_targets = filterEnabledTargets(options.targets);\n let getPanelItems = _.map(enabled_targets, t => {\n let target = _.cloneDeep(t);\n this.replaceTargetVariables(target, options);\n return this.zabbix.getItemsFromTarget(target, {itemtype: 'num'});\n });\n\n return Promise.all(getPanelItems)\n .then(results => {\n let items = _.flatten(results);\n let itemids = _.map(items, 'itemid');\n\n if (itemids.length === 0) {\n return [];\n }\n return this.zabbix.getAlerts(itemids);\n })\n .then(triggers => {\n triggers = _.filter(triggers, trigger => {\n return trigger.priority >= this.alertingMinSeverity;\n });\n\n if (!triggers || triggers.length === 0) {\n return {};\n }\n\n let state = 'ok';\n\n let firedTriggers = _.filter(triggers, {value: '1'});\n if (firedTriggers.length) {\n state = 'alerting';\n }\n\n let thresholds = _.map(triggers, trigger => {\n return getTriggerThreshold(trigger.expression);\n });\n\n return {\n panelId: options.panelId,\n state: state,\n thresholds: thresholds\n };\n });\n }\n\n // Replace template variables\n replaceTargetVariables(target, options) {\n let parts = ['group', 'host', 'application', 'item'];\n _.forEach(parts, p => {\n if (target[p] && target[p].filter) {\n target[p].filter = this.replaceTemplateVars(target[p].filter, options.scopedVars);\n }\n });\n target.textFilter = this.replaceTemplateVars(target.textFilter, options.scopedVars);\n\n _.forEach(target.functions, func => {\n func.params = _.map(func.params, param => {\n if (typeof param === 'number') {\n return +this.templateSrv.replace(param.toString(), options.scopedVars);\n } else {\n return this.templateSrv.replace(param, options.scopedVars);\n }\n });\n });\n }\n\n isUseTrends(timeRange) {\n let [timeFrom, timeTo] = timeRange;\n let useTrendsFrom = Math.ceil(dateMath.parse('now-' + this.trendsFrom) / 1000);\n let useTrendsRange = Math.ceil(utils.parseInterval(this.trendsRange) / 1000);\n let useTrends = this.trends && (\n (timeFrom <= useTrendsFrom) ||\n (timeTo - timeFrom >= useTrendsRange)\n );\n return useTrends;\n }\n}\n\nfunction bindFunctionDefs(functionDefs, category) {\n var aggregationFunctions = _.map(metricFunctions.getCategories()[category], 'name');\n var aggFuncDefs = _.filter(functionDefs, function(func) {\n return _.includes(aggregationFunctions, func.def.name);\n });\n\n return _.map(aggFuncDefs, function(func) {\n var funcInstance = metricFunctions.createFuncInstance(func.def, func.params);\n return funcInstance.bindFunction(dataProcessor.metricFunctions);\n });\n}\n\nfunction getConsolidateBy(target) {\n let consolidateBy;\n let funcDef = _.find(target.functions, func => {\n return func.def.name === 'consolidateBy';\n });\n if (funcDef && funcDef.params && funcDef.params.length) {\n consolidateBy = funcDef.params[0];\n }\n return consolidateBy;\n}\n\nfunction downsampleSeries(timeseries_data, options) {\n let defaultAgg = dataProcessor.aggregationFunctions['avg'];\n let consolidateByFunc = dataProcessor.aggregationFunctions[options.consolidateBy] || defaultAgg;\n return _.map(timeseries_data, timeseries => {\n if (timeseries.datapoints.length > options.maxDataPoints) {\n timeseries.datapoints = dataProcessor\n .groupBy(options.interval, consolidateByFunc, timeseries.datapoints);\n }\n return timeseries;\n });\n}\n\nfunction formatMetric(metricObj) {\n return {\n text: metricObj.name,\n expandable: false\n };\n}\n\n/**\n * Custom formatter for template variables.\n * Default Grafana \"regex\" formatter returns\n * value1|value2\n * This formatter returns\n * (value1|value2)\n * This format needed for using in complex regex with\n * template variables, for example\n * /CPU $cpu_item.*time/ where $cpu_item is system,user,iowait\n */\nfunction zabbixTemplateFormat(value) {\n if (typeof value === 'string') {\n return utils.escapeRegex(value);\n }\n\n var escapedValues = _.map(value, utils.escapeRegex);\n return '(' + escapedValues.join('|') + ')';\n}\n\nfunction zabbixItemIdsTemplateFormat(value) {\n if (typeof value === 'string') {\n return value;\n }\n return value.join(',');\n}\n\n/**\n * If template variables are used in request, replace it using regex format\n * and wrap with '/' for proper multi-value work. Example:\n * $variable selected as a, b, c\n * We use filter $variable\n * $variable -> a|b|c -> /a|b|c/\n * /$variable/ -> /a|b|c/ -> /a|b|c/\n */\nfunction replaceTemplateVars(templateSrv, target, scopedVars) {\n var replacedTarget = templateSrv.replace(target, scopedVars, zabbixTemplateFormat);\n if (target !== replacedTarget && !utils.isRegex(replacedTarget)) {\n replacedTarget = '/^' + replacedTarget + '$/';\n }\n return replacedTarget;\n}\n\n// Apply function one by one:\n// sequence([a(), b(), c()]) = c(b(a()));\nfunction sequence(funcsArray) {\n return function(result) {\n for (var i = 0; i < funcsArray.length; i++) {\n result = funcsArray[i].call(this, result);\n }\n return result;\n };\n}\n\nfunction filterEnabledTargets(targets) {\n return _.filter(targets, target => {\n return !(target.hide || !target.group || !target.host || !target.item);\n });\n}\n\nfunction getTriggerThreshold(expression) {\n let thresholdPattern = /.*[<>=]{1,2}([\\d\\.]+)/;\n let finded_thresholds = expression.match(thresholdPattern);\n if (finded_thresholds && finded_thresholds.length >= 2) {\n let threshold = finded_thresholds[1];\n threshold = Number(threshold);\n return threshold;\n } else {\n return null;\n }\n}\n\nexport {ZabbixAPIDatasource, zabbixTemplateFormat};\n\n// Fix for backward compatibility with lodash 2.4\nif (!_.includes) {_.includes = _.contains;}\nif (!_.keyBy) {_.keyBy = _.indexBy;}\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/responseHandler.js b/dist/datasource-zabbix/responseHandler.js index fad1d09..82e61ba 100644 --- a/dist/datasource-zabbix/responseHandler.js +++ b/dist/datasource-zabbix/responseHandler.js @@ -56,23 +56,33 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex }); } - function handleHistory(history, items) { + function sortTimeseries(timeseries) { + // Sort trend data, issue #202 + _.forEach(timeseries, function (series) { + series.datapoints = _.sortBy(series.datapoints, function (point) { + return point[c.DATAPOINT_TS]; + }); + }); + return timeseries; + }function handleHistory(history, items) { var addHostName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; return convertHistory(history, items, addHostName, convertHistoryPoint); - }function handleTrends(history, items, valueType) { + } + + function handleTrends(history, items, valueType) { var addHostName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; var convertPointCallback = _.partial(convertTrendPoint, valueType); return convertHistory(history, items, addHostName, convertPointCallback); - } - - function handleText(history, items, target) { + }function handleText(history, items, target) { var addHostName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; var convertTextCallback = _.partial(convertText, target); return convertHistory(history, items, addHostName, convertTextCallback); - }function handleHistoryAsTable(history, items, target) { + } + + function handleHistoryAsTable(history, items, target) { var table = new TableModel(); table.addColumn({ text: 'Host' }); table.addColumn({ text: 'Item' }); @@ -101,9 +111,7 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex }); return table; - } - - function convertText(target, point) { + }function convertText(target, point) { var value = point.value; // Regex-based extractor @@ -112,7 +120,9 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex } return [value, point.clock * 1000 + Math.round(point.ns / 1000000)]; - }function extractText(str, pattern, useCaptureGroups) { + } + + function extractText(str, pattern, useCaptureGroups) { var extractPattern = new RegExp(pattern); var extractedValue = extractPattern.exec(str); if (extractedValue) { @@ -123,9 +133,7 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex } } return extractedValue; - } - - function handleSLAResponse(itservice, slaProperty, slaObject) { + }function handleSLAResponse(itservice, slaProperty, slaObject) { var targetSLA = slaObject[itservice.serviceid].sla[0]; if (slaProperty.property === 'status') { var targetStatus = parseInt(slaObject[itservice.serviceid].status); @@ -139,7 +147,9 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex datapoints: [[targetSLA[slaProperty.property], targetSLA.from * 1000], [targetSLA[slaProperty.property], targetSLA.to * 1000]] }; } - }function handleTriggersResponse(triggers, timeRange) { + } + + function handleTriggersResponse(triggers, timeRange) { if (_.isNumber(triggers)) { return { target: "triggers count", @@ -163,9 +173,7 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex }); return table; } - } - - function getTriggerStats(triggers) { + }function getTriggerStats(triggers) { var groups = _.uniq(_.flattenDeep(_.map(triggers, function (trigger) { return _.map(trigger.groups, 'name'); }))); @@ -180,12 +188,12 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex }); }); return stats; - }function convertHistoryPoint(point) { - // Value must be a number for properly work - return [Number(point.value), point.clock * 1000 + Math.round(point.ns / 1000000)]; } - function convertTrendPoint(valueType, point) { + function convertHistoryPoint(point) { + // Value must be a number for properly work + return [Number(point.value), point.clock * 1000 + Math.round(point.ns / 1000000)]; + }function convertTrendPoint(valueType, point) { var value; switch (valueType) { case "min": @@ -208,7 +216,9 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex } return [Number(value), point.clock * 1000]; - }return { + } + + return { setters: [function (_lodash) { _ = _lodash.default; }, function (_appCoreTable_model) { @@ -224,7 +234,8 @@ System.register(['lodash', 'app/core/table_model', './constants'], function (_ex handleText: handleText, handleHistoryAsTable: handleHistoryAsTable, handleSLAResponse: handleSLAResponse, - handleTriggersResponse: handleTriggersResponse + handleTriggersResponse: handleTriggersResponse, + sortTimeseries: sortTimeseries }); // Fix for backward compatibility with lodash 2.4 diff --git a/dist/datasource-zabbix/responseHandler.js.map b/dist/datasource-zabbix/responseHandler.js.map index aad8c3e..5219276 100644 --- a/dist/datasource-zabbix/responseHandler.js.map +++ b/dist/datasource-zabbix/responseHandler.js.map @@ -1 +1 @@ -{"version":3,"sources":["../../src/datasource-zabbix/responseHandler.js"],"names":["convertHistory","history","items","addHostName","convertPointCallback","grouped_history","_","groupBy","hosts","uniqBy","flatten","map","hist","itemid","item","find","alias","name","keys","length","host","hostid","target","datapoints","handleHistory","convertHistoryPoint","handleTrends","valueType","partial","convertTrendPoint","handleText","convertTextCallback","convertText","handleHistoryAsTable","table","TableModel","addColumn","text","each","itemHistory","lastPoint","last","lastValue","value","options","skipEmptyValues","textFilter","extractText","useCaptureGroups","first","rows","push","key_","point","clock","Math","round","ns","str","pattern","extractPattern","RegExp","extractedValue","exec","handleSLAResponse","itservice","slaProperty","slaObject","targetSLA","serviceid","sla","property","targetStatus","parseInt","status","to","from","handleTriggersResponse","triggers","timeRange","isNumber","stats","getTriggerStats","orderBy","c","TRIGGER_SEVERITY","severity","severity_stats","group","row","toPairs","s","concat","groups","uniq","flattenDeep","trigger","priority","Number","value_min","value_max","value_avg","value_sum","value_count"],"mappings":"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","file":"responseHandler.js","sourcesContent":["import _ from 'lodash';\nimport TableModel from 'app/core/table_model';\nimport * as c from './constants';\n\n/**\n * Convert Zabbix API history.get response to Grafana format\n *\n * @return {Array} Array of timeseries in Grafana format\n * {\n * target: \"Metric name\",\n * datapoints: [[, ], ...]\n * }\n */\nfunction convertHistory(history, items, addHostName, convertPointCallback) {\n /**\n * Response should be in the format:\n * data: [\n * {\n * target: \"Metric name\",\n * datapoints: [[, ], ...]\n * }, ...\n * ]\n */\n\n // Group history by itemid\n var grouped_history = _.groupBy(history, 'itemid');\n var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid'); //uniqBy is needed to deduplicate\n\n return _.map(grouped_history, function(hist, itemid) {\n var item = _.find(items, {'itemid': itemid});\n var alias = item.name;\n if (_.keys(hosts).length > 1 && addHostName) { //only when actual multi hosts selected\n var host = _.find(hosts, {'hostid': item.hostid});\n alias = host.name + \": \" + alias;\n }\n return {\n target: alias,\n datapoints: _.map(hist, convertPointCallback)\n };\n });\n}\n\nfunction handleHistory(history, items, addHostName = true) {\n return convertHistory(history, items, addHostName, convertHistoryPoint);\n}\n\nfunction handleTrends(history, items, valueType, addHostName = true) {\n var convertPointCallback = _.partial(convertTrendPoint, valueType);\n return convertHistory(history, items, addHostName, convertPointCallback);\n}\n\nfunction handleText(history, items, target, addHostName = true) {\n let convertTextCallback = _.partial(convertText, target);\n return convertHistory(history, items, addHostName, convertTextCallback);\n}\n\nfunction handleHistoryAsTable(history, items, target) {\n let table = new TableModel();\n table.addColumn({text: 'Host'});\n table.addColumn({text: 'Item'});\n table.addColumn({text: 'Key'});\n table.addColumn({text: 'Last value'});\n\n let grouped_history = _.groupBy(history, 'itemid');\n _.each(items, (item) => {\n let itemHistory = grouped_history[item.itemid] || [];\n let lastPoint = _.last(itemHistory);\n let lastValue = lastPoint ? lastPoint.value : null;\n\n if(target.options.skipEmptyValues && (!lastValue || lastValue === '')) {\n return;\n }\n\n // Regex-based extractor\n if (target.textFilter) {\n lastValue = extractText(lastValue, target.textFilter, target.useCaptureGroups);\n }\n\n let host = _.first(item.hosts);\n host = host ? host.name : \"\";\n\n table.rows.push([\n host, item.name, item.key_, lastValue\n ]);\n });\n\n return table;\n}\n\nfunction convertText(target, point) {\n let value = point.value;\n\n // Regex-based extractor\n if (target.textFilter) {\n value = extractText(point.value, target.textFilter, target.useCaptureGroups);\n }\n\n return [\n value,\n point.clock * 1000 + Math.round(point.ns / 1000000)\n ];\n}\n\nfunction extractText(str, pattern, useCaptureGroups) {\n let extractPattern = new RegExp(pattern);\n let extractedValue = extractPattern.exec(str);\n if (extractedValue) {\n if (useCaptureGroups) {\n extractedValue = extractedValue[1];\n } else {\n extractedValue = extractedValue[0];\n }\n }\n return extractedValue;\n}\n\nfunction handleSLAResponse(itservice, slaProperty, slaObject) {\n var targetSLA = slaObject[itservice.serviceid].sla[0];\n if (slaProperty.property === 'status') {\n var targetStatus = parseInt(slaObject[itservice.serviceid].status);\n return {\n target: itservice.name + ' ' + slaProperty.name,\n datapoints: [\n [targetStatus, targetSLA.to * 1000]\n ]\n };\n } else {\n return {\n target: itservice.name + ' ' + slaProperty.name,\n datapoints: [\n [targetSLA[slaProperty.property], targetSLA.from * 1000],\n [targetSLA[slaProperty.property], targetSLA.to * 1000]\n ]\n };\n }\n}\n\nfunction handleTriggersResponse(triggers, timeRange) {\n if (_.isNumber(triggers)) {\n return {\n target: \"triggers count\",\n datapoints: [\n [triggers, timeRange[1] * 1000]\n ]\n };\n } else {\n let stats = getTriggerStats(triggers);\n let table = new TableModel();\n table.addColumn({text: 'Host group'});\n _.each(_.orderBy(c.TRIGGER_SEVERITY, ['val'], ['desc']), (severity) => {\n table.addColumn({text: severity.text});\n });\n _.each(stats, (severity_stats, group) => {\n let row = _.map(_.orderBy(_.toPairs(severity_stats), (s) => s[0], ['desc']), (s) => s[1]);\n row = _.concat([group], ...row);\n table.rows.push(row);\n });\n return table;\n }\n}\n\nfunction getTriggerStats(triggers) {\n let groups = _.uniq(_.flattenDeep(_.map(triggers, (trigger) => _.map(trigger.groups, 'name'))));\n // let severity = _.map(c.TRIGGER_SEVERITY, 'text');\n let stats = {};\n _.each(groups, (group) => {\n stats[group] = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0}; // severity:count\n });\n _.each(triggers, (trigger) => {\n _.each(trigger.groups, (group) => {\n stats[group.name][trigger.priority]++;\n });\n });\n return stats;\n}\n\nfunction convertHistoryPoint(point) {\n // Value must be a number for properly work\n return [\n Number(point.value),\n point.clock * 1000 + Math.round(point.ns / 1000000)\n ];\n}\n\nfunction convertTrendPoint(valueType, point) {\n var value;\n switch (valueType) {\n case \"min\":\n value = point.value_min;\n break;\n case \"max\":\n value = point.value_max;\n break;\n case \"avg\":\n value = point.value_avg;\n break;\n case \"sum\":\n value = point.value_sum;\n break;\n case \"count\":\n value = point.value_count;\n break;\n default:\n value = point.value_avg;\n }\n\n return [\n Number(value),\n point.clock * 1000\n ];\n}\n\nexport default {\n handleHistory: handleHistory,\n convertHistory: convertHistory,\n handleTrends: handleTrends,\n handleText: handleText,\n handleHistoryAsTable: handleHistoryAsTable,\n handleSLAResponse: handleSLAResponse,\n handleTriggersResponse: handleTriggersResponse\n};\n\n// Fix for backward compatibility with lodash 2.4\nif (!_.uniqBy) {_.uniqBy = _.uniq;}\n"]} \ No newline at end of file +{"version":3,"sources":["../../src/datasource-zabbix/responseHandler.js"],"names":["convertHistory","history","items","addHostName","convertPointCallback","grouped_history","_","groupBy","hosts","uniqBy","flatten","map","hist","itemid","item","find","alias","name","keys","length","host","hostid","target","datapoints","sortTimeseries","timeseries","forEach","series","sortBy","point","c","DATAPOINT_TS","handleHistory","convertHistoryPoint","handleTrends","valueType","partial","convertTrendPoint","handleText","convertTextCallback","convertText","handleHistoryAsTable","table","TableModel","addColumn","text","each","itemHistory","lastPoint","last","lastValue","value","options","skipEmptyValues","textFilter","extractText","useCaptureGroups","first","rows","push","key_","clock","Math","round","ns","str","pattern","extractPattern","RegExp","extractedValue","exec","handleSLAResponse","itservice","slaProperty","slaObject","targetSLA","serviceid","sla","property","targetStatus","parseInt","status","to","from","handleTriggersResponse","triggers","timeRange","isNumber","stats","getTriggerStats","orderBy","TRIGGER_SEVERITY","severity","severity_stats","group","row","toPairs","s","concat","groups","uniq","flattenDeep","trigger","priority","Number","value_min","value_max","value_avg","value_sum","value_count"],"mappings":"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","file":"responseHandler.js","sourcesContent":["import _ from 'lodash';\nimport TableModel from 'app/core/table_model';\nimport * as c from './constants';\n\n/**\n * Convert Zabbix API history.get response to Grafana format\n *\n * @return {Array} Array of timeseries in Grafana format\n * {\n * target: \"Metric name\",\n * datapoints: [[, ], ...]\n * }\n */\nfunction convertHistory(history, items, addHostName, convertPointCallback) {\n /**\n * Response should be in the format:\n * data: [\n * {\n * target: \"Metric name\",\n * datapoints: [[, ], ...]\n * }, ...\n * ]\n */\n\n // Group history by itemid\n var grouped_history = _.groupBy(history, 'itemid');\n var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid'); //uniqBy is needed to deduplicate\n\n return _.map(grouped_history, function(hist, itemid) {\n var item = _.find(items, {'itemid': itemid});\n var alias = item.name;\n if (_.keys(hosts).length > 1 && addHostName) { //only when actual multi hosts selected\n var host = _.find(hosts, {'hostid': item.hostid});\n alias = host.name + \": \" + alias;\n }\n return {\n target: alias,\n datapoints: _.map(hist, convertPointCallback)\n };\n });\n}\n\nfunction sortTimeseries(timeseries) {\n // Sort trend data, issue #202\n _.forEach(timeseries, series => {\n series.datapoints = _.sortBy(series.datapoints, point => point[c.DATAPOINT_TS]);\n });\n return timeseries;\n}\n\nfunction handleHistory(history, items, addHostName = true) {\n return convertHistory(history, items, addHostName, convertHistoryPoint);\n}\n\nfunction handleTrends(history, items, valueType, addHostName = true) {\n var convertPointCallback = _.partial(convertTrendPoint, valueType);\n return convertHistory(history, items, addHostName, convertPointCallback);\n}\n\nfunction handleText(history, items, target, addHostName = true) {\n let convertTextCallback = _.partial(convertText, target);\n return convertHistory(history, items, addHostName, convertTextCallback);\n}\n\nfunction handleHistoryAsTable(history, items, target) {\n let table = new TableModel();\n table.addColumn({text: 'Host'});\n table.addColumn({text: 'Item'});\n table.addColumn({text: 'Key'});\n table.addColumn({text: 'Last value'});\n\n let grouped_history = _.groupBy(history, 'itemid');\n _.each(items, (item) => {\n let itemHistory = grouped_history[item.itemid] || [];\n let lastPoint = _.last(itemHistory);\n let lastValue = lastPoint ? lastPoint.value : null;\n\n if(target.options.skipEmptyValues && (!lastValue || lastValue === '')) {\n return;\n }\n\n // Regex-based extractor\n if (target.textFilter) {\n lastValue = extractText(lastValue, target.textFilter, target.useCaptureGroups);\n }\n\n let host = _.first(item.hosts);\n host = host ? host.name : \"\";\n\n table.rows.push([\n host, item.name, item.key_, lastValue\n ]);\n });\n\n return table;\n}\n\nfunction convertText(target, point) {\n let value = point.value;\n\n // Regex-based extractor\n if (target.textFilter) {\n value = extractText(point.value, target.textFilter, target.useCaptureGroups);\n }\n\n return [\n value,\n point.clock * 1000 + Math.round(point.ns / 1000000)\n ];\n}\n\nfunction extractText(str, pattern, useCaptureGroups) {\n let extractPattern = new RegExp(pattern);\n let extractedValue = extractPattern.exec(str);\n if (extractedValue) {\n if (useCaptureGroups) {\n extractedValue = extractedValue[1];\n } else {\n extractedValue = extractedValue[0];\n }\n }\n return extractedValue;\n}\n\nfunction handleSLAResponse(itservice, slaProperty, slaObject) {\n var targetSLA = slaObject[itservice.serviceid].sla[0];\n if (slaProperty.property === 'status') {\n var targetStatus = parseInt(slaObject[itservice.serviceid].status);\n return {\n target: itservice.name + ' ' + slaProperty.name,\n datapoints: [\n [targetStatus, targetSLA.to * 1000]\n ]\n };\n } else {\n return {\n target: itservice.name + ' ' + slaProperty.name,\n datapoints: [\n [targetSLA[slaProperty.property], targetSLA.from * 1000],\n [targetSLA[slaProperty.property], targetSLA.to * 1000]\n ]\n };\n }\n}\n\nfunction handleTriggersResponse(triggers, timeRange) {\n if (_.isNumber(triggers)) {\n return {\n target: \"triggers count\",\n datapoints: [\n [triggers, timeRange[1] * 1000]\n ]\n };\n } else {\n let stats = getTriggerStats(triggers);\n let table = new TableModel();\n table.addColumn({text: 'Host group'});\n _.each(_.orderBy(c.TRIGGER_SEVERITY, ['val'], ['desc']), (severity) => {\n table.addColumn({text: severity.text});\n });\n _.each(stats, (severity_stats, group) => {\n let row = _.map(_.orderBy(_.toPairs(severity_stats), (s) => s[0], ['desc']), (s) => s[1]);\n row = _.concat([group], ...row);\n table.rows.push(row);\n });\n return table;\n }\n}\n\nfunction getTriggerStats(triggers) {\n let groups = _.uniq(_.flattenDeep(_.map(triggers, (trigger) => _.map(trigger.groups, 'name'))));\n // let severity = _.map(c.TRIGGER_SEVERITY, 'text');\n let stats = {};\n _.each(groups, (group) => {\n stats[group] = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0}; // severity:count\n });\n _.each(triggers, (trigger) => {\n _.each(trigger.groups, (group) => {\n stats[group.name][trigger.priority]++;\n });\n });\n return stats;\n}\n\nfunction convertHistoryPoint(point) {\n // Value must be a number for properly work\n return [\n Number(point.value),\n point.clock * 1000 + Math.round(point.ns / 1000000)\n ];\n}\n\nfunction convertTrendPoint(valueType, point) {\n var value;\n switch (valueType) {\n case \"min\":\n value = point.value_min;\n break;\n case \"max\":\n value = point.value_max;\n break;\n case \"avg\":\n value = point.value_avg;\n break;\n case \"sum\":\n value = point.value_sum;\n break;\n case \"count\":\n value = point.value_count;\n break;\n default:\n value = point.value_avg;\n }\n\n return [\n Number(value),\n point.clock * 1000\n ];\n}\n\nexport default {\n handleHistory,\n convertHistory,\n handleTrends,\n handleText,\n handleHistoryAsTable,\n handleSLAResponse,\n handleTriggersResponse,\n sortTimeseries\n};\n\n// Fix for backward compatibility with lodash 2.4\nif (!_.uniqBy) {_.uniqBy = _.uniq;}\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/dbConnector.js b/dist/datasource-zabbix/zabbix/connectors/dbConnector.js new file mode 100644 index 0000000..2e5facb --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/dbConnector.js @@ -0,0 +1,89 @@ +'use strict'; + +System.register(['lodash'], function (_export, _context) { + "use strict"; + + var _, _createClass, NOT_IMPLEMENTED, DBConnector; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + return { + setters: [function (_lodash) { + _ = _lodash.default; + }], + execute: function () { + _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + NOT_IMPLEMENTED = 'Method should be implemented in subclass of DBConnector'; + + DBConnector = function () { + function DBConnector(options, backendSrv, datasourceSrv) { + _classCallCheck(this, DBConnector); + + this.backendSrv = backendSrv; + this.datasourceSrv = datasourceSrv; + this.datasourceId = options.datasourceId; + this.datasourceName = options.datasourceName; + this.datasourceType = null; + } + + _createClass(DBConnector, [{ + key: 'loadDBDataSource', + value: function loadDBDataSource() { + var _this = this; + + var ds = _.find(this.datasourceSrv.getAll(), { 'id': this.datasourceId }); + if (ds) { + return this.datasourceSrv.loadDatasource(ds.name).then(function (ds) { + _this.datasourceType = ds.meta.id; + return ds; + }); + } else { + return Promise.reject('SQL Data Source with ID ' + this.datasourceId + ' not found'); + } + } + }, { + key: 'testDataSource', + value: function testDataSource() { + throw NOT_IMPLEMENTED; + } + }, { + key: 'getHistory', + value: function getHistory() { + throw NOT_IMPLEMENTED; + } + }, { + key: 'getTrends', + value: function getTrends() { + throw NOT_IMPLEMENTED; + } + }]); + + return DBConnector; + }(); + + _export('default', DBConnector); + } + }; +}); +//# sourceMappingURL=dbConnector.js.map diff --git a/dist/datasource-zabbix/zabbix/connectors/dbConnector.js.map b/dist/datasource-zabbix/zabbix/connectors/dbConnector.js.map new file mode 100644 index 0000000..bb80c45 --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/dbConnector.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../../../src/datasource-zabbix/zabbix/connectors/dbConnector.js"],"names":["_","NOT_IMPLEMENTED","DBConnector","options","backendSrv","datasourceSrv","datasourceId","datasourceName","datasourceType","ds","find","getAll","loadDatasource","name","then","meta","id","Promise","reject"],"mappings":";;;;;;;;;;;;;;;AAAOA,O;;;;;;;;;;;;;;;;;;;;;AAEDC,qB,GAAkB,yD;;AAEHC,iB;AACnB,6BAAYC,OAAZ,EAAqBC,UAArB,EAAiCC,aAAjC,EAAgD;AAAA;;AAC9C,eAAKD,UAAL,GAAkBA,UAAlB;AACA,eAAKC,aAAL,GAAqBA,aAArB;AACA,eAAKC,YAAL,GAAoBH,QAAQG,YAA5B;AACA,eAAKC,cAAL,GAAsBJ,QAAQI,cAA9B;AACA,eAAKC,cAAL,GAAsB,IAAtB;AACD;;;;6CAEkB;AAAA;;AACjB,gBAAIC,KAAKT,EAAEU,IAAF,CAAO,KAAKL,aAAL,CAAmBM,MAAnB,EAAP,EAAoC,EAAC,MAAM,KAAKL,YAAZ,EAApC,CAAT;AACA,gBAAIG,EAAJ,EAAQ;AACN,qBAAO,KAAKJ,aAAL,CAAmBO,cAAnB,CAAkCH,GAAGI,IAArC,EACNC,IADM,CACD,cAAM;AACV,sBAAKN,cAAL,GAAsBC,GAAGM,IAAH,CAAQC,EAA9B;AACA,uBAAOP,EAAP;AACD,eAJM,CAAP;AAKD,aAND,MAMO;AACL,qBAAOQ,QAAQC,MAAR,8BAA0C,KAAKZ,YAA/C,gBAAP;AACD;AACF;;;2CAEgB;AACf,kBAAML,eAAN;AACD;;;uCAEY;AACX,kBAAMA,eAAN;AACD;;;sCAEW;AACV,kBAAMA,eAAN;AACD;;;;;;yBAhCkBC,W","file":"dbConnector.js","sourcesContent":["import _ from 'lodash';\n\nconst NOT_IMPLEMENTED = 'Method should be implemented in subclass of DBConnector';\n\nexport default class DBConnector {\n constructor(options, backendSrv, datasourceSrv) {\n this.backendSrv = backendSrv;\n this.datasourceSrv = datasourceSrv;\n this.datasourceId = options.datasourceId;\n this.datasourceName = options.datasourceName;\n this.datasourceType = null;\n }\n\n loadDBDataSource() {\n let ds = _.find(this.datasourceSrv.getAll(), {'id': this.datasourceId});\n if (ds) {\n return this.datasourceSrv.loadDatasource(ds.name)\n .then(ds => {\n this.datasourceType = ds.meta.id;\n return ds;\n });\n } else {\n return Promise.reject(`SQL Data Source with ID ${this.datasourceId} not found`);\n }\n }\n\n testDataSource() {\n throw NOT_IMPLEMENTED;\n }\n\n getHistory() {\n throw NOT_IMPLEMENTED;\n }\n\n getTrends() {\n throw NOT_IMPLEMENTED;\n }\n}\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/mysql.js b/dist/datasource-zabbix/zabbix/connectors/sql/mysql.js new file mode 100644 index 0000000..34f8e3d --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/sql/mysql.js @@ -0,0 +1,41 @@ +"use strict"; + +System.register([], function (_export, _context) { + "use strict"; + + var TEST_QUERY, mysql; + /** + * MySQL queries + */ + + function historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) { + var time_expression = "clock DIV " + intervalSec + " * " + intervalSec; + var query = "\n SELECT CAST(itemid AS CHAR) AS metric, " + time_expression + " AS time_sec, " + aggFunction + "(value) AS value\n FROM " + table + "\n WHERE itemid IN (" + itemids + ")\n AND clock > " + timeFrom + " AND clock < " + timeTill + "\n GROUP BY " + time_expression + ", metric\n ORDER BY time_sec ASC\n "; + return query; + } + + function trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) { + var time_expression = "clock DIV " + intervalSec + " * " + intervalSec; + var query = "\n SELECT CAST(itemid AS CHAR) AS metric, " + time_expression + " AS time_sec, " + aggFunction + "(" + valueColumn + ") AS value\n FROM " + table + "\n WHERE itemid IN (" + itemids + ")\n AND clock > " + timeFrom + " AND clock < " + timeTill + "\n GROUP BY " + time_expression + ", metric\n ORDER BY time_sec ASC\n "; + return query; + } + + function testQuery() { + return TEST_QUERY; + } + + return { + setters: [], + execute: function () { + TEST_QUERY = "SELECT CAST(itemid AS CHAR) AS metric, clock AS time_sec, value_avg AS value FROM trends_uint LIMIT 1"; + mysql = { + historyQuery: historyQuery, + trendsQuery: trendsQuery, + testQuery: testQuery + }; + + _export("default", mysql); + } + }; +}); +//# sourceMappingURL=mysql.js.map diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/mysql.js.map b/dist/datasource-zabbix/zabbix/connectors/sql/mysql.js.map new file mode 100644 index 0000000..befe5fb --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/sql/mysql.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../../../../src/datasource-zabbix/zabbix/connectors/sql/mysql.js"],"names":["historyQuery","itemids","table","timeFrom","timeTill","intervalSec","aggFunction","time_expression","query","trendsQuery","valueColumn","testQuery","TEST_QUERY","mysql"],"mappings":";;;;;;AAAA;;;;AAIA,WAASA,YAAT,CAAsBC,OAAtB,EAA+BC,KAA/B,EAAsCC,QAAtC,EAAgDC,QAAhD,EAA0DC,WAA1D,EAAuEC,WAAvE,EAAoF;AAClF,QAAIC,iCAA+BF,WAA/B,WAAgDA,WAApD;AACA,QAAIG,0DACuCD,eADvC,sBACuED,WADvE,mCAEKJ,KAFL,+BAGiBD,OAHjB,6BAIcE,QAJd,qBAIsCC,QAJtC,uBAKSG,eALT,4CAAJ;AAQA,WAAOC,KAAP;AACD;;AAED,WAASC,WAAT,CAAqBR,OAArB,EAA8BC,KAA9B,EAAqCC,QAArC,EAA+CC,QAA/C,EAAyDC,WAAzD,EAAsEC,WAAtE,EAAmFI,WAAnF,EAAgG;AAC9F,QAAIH,iCAA+BF,WAA/B,WAAgDA,WAApD;AACA,QAAIG,0DACuCD,eADvC,sBACuED,WADvE,SACsFI,WADtF,6BAEKR,KAFL,+BAGiBD,OAHjB,6BAIcE,QAJd,qBAIsCC,QAJtC,uBAKSG,eALT,4CAAJ;AAQA,WAAOC,KAAP;AACD;;AAID,WAASG,SAAT,GAAqB;AACnB,WAAOC,UAAP;AACD;;;;;AAJKA,gB;AAMAC,W,GAAQ;AACZb,kCADY;AAEZS,gCAFY;AAGZE;AAHY,O;;yBAMCE,K","file":"mysql.js","sourcesContent":["/**\n * MySQL queries\n */\n\nfunction historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) {\n let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT CAST(itemid AS CHAR) AS metric, ${time_expression} AS time_sec, ${aggFunction}(value) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY ${time_expression}, metric\n ORDER BY time_sec ASC\n `;\n return query;\n}\n\nfunction trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) {\n let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT CAST(itemid AS CHAR) AS metric, ${time_expression} AS time_sec, ${aggFunction}(${valueColumn}) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY ${time_expression}, metric\n ORDER BY time_sec ASC\n `;\n return query;\n}\n\nconst TEST_QUERY = `SELECT CAST(itemid AS CHAR) AS metric, clock AS time_sec, value_avg AS value FROM trends_uint LIMIT 1`;\n\nfunction testQuery() {\n return TEST_QUERY;\n}\n\nconst mysql = {\n historyQuery,\n trendsQuery,\n testQuery\n};\n\nexport default mysql;\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/postgres.js b/dist/datasource-zabbix/zabbix/connectors/sql/postgres.js new file mode 100644 index 0000000..9975800 --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/sql/postgres.js @@ -0,0 +1,40 @@ +'use strict'; + +System.register([], function (_export, _context) { + "use strict"; + + var ITEMID_FORMAT, TEST_QUERY, postgres; + + + function historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) { + var time_expression = 'clock / ' + intervalSec + ' * ' + intervalSec; + var query = '\n SELECT to_char(itemid, \'' + ITEMID_FORMAT + '\') AS metric, ' + time_expression + ' AS time, ' + aggFunction + '(value) AS value\n FROM ' + table + '\n WHERE itemid IN (' + itemids + ')\n AND clock > ' + timeFrom + ' AND clock < ' + timeTill + '\n GROUP BY 1, 2\n ORDER BY time ASC\n '; + return query; + } + + function trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) { + var time_expression = 'clock / ' + intervalSec + ' * ' + intervalSec; + var query = '\n SELECT to_char(itemid, \'' + ITEMID_FORMAT + '\') AS metric, ' + time_expression + ' AS time, ' + aggFunction + '(' + valueColumn + ') AS value\n FROM ' + table + '\n WHERE itemid IN (' + itemids + ')\n AND clock > ' + timeFrom + ' AND clock < ' + timeTill + '\n GROUP BY 1, 2\n ORDER BY time ASC\n '; + return query; + } + + function testQuery() { + return TEST_QUERY; + } + + return { + setters: [], + execute: function () { + ITEMID_FORMAT = 'FM99999999999999999999'; + TEST_QUERY = '\n SELECT to_char(itemid, \'' + ITEMID_FORMAT + '\') AS metric, clock AS time, value_avg AS value\n FROM trends_uint LIMIT 1\n'; + postgres = { + historyQuery: historyQuery, + trendsQuery: trendsQuery, + testQuery: testQuery + }; + + _export('default', postgres); + } + }; +}); +//# sourceMappingURL=postgres.js.map diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/postgres.js.map b/dist/datasource-zabbix/zabbix/connectors/sql/postgres.js.map new file mode 100644 index 0000000..6e110df --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/sql/postgres.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../../../../src/datasource-zabbix/zabbix/connectors/sql/postgres.js"],"names":["historyQuery","itemids","table","timeFrom","timeTill","intervalSec","aggFunction","time_expression","query","ITEMID_FORMAT","trendsQuery","valueColumn","testQuery","TEST_QUERY","postgres"],"mappings":";;;;;;;;AAMA,WAASA,YAAT,CAAsBC,OAAtB,EAA+BC,KAA/B,EAAsCC,QAAtC,EAAgDC,QAAhD,EAA0DC,WAA1D,EAAuEC,WAAvE,EAAoF;AAClF,QAAIC,+BAA6BF,WAA7B,WAA8CA,WAAlD;AACA,QAAIG,4CACwBC,aADxB,uBACsDF,eADtD,kBACkFD,WADlF,mCAEKJ,KAFL,+BAGiBD,OAHjB,6BAIcE,QAJd,qBAIsCC,QAJtC,mDAAJ;AAQA,WAAOI,KAAP;AACD;;AAED,WAASE,WAAT,CAAqBT,OAArB,EAA8BC,KAA9B,EAAqCC,QAArC,EAA+CC,QAA/C,EAAyDC,WAAzD,EAAsEC,WAAtE,EAAmFK,WAAnF,EAAgG;AAC9F,QAAIJ,+BAA6BF,WAA7B,WAA8CA,WAAlD;AACA,QAAIG,4CACwBC,aADxB,uBACsDF,eADtD,kBACkFD,WADlF,SACiGK,WADjG,6BAEKT,KAFL,+BAGiBD,OAHjB,6BAIcE,QAJd,qBAIsCC,QAJtC,mDAAJ;AAQA,WAAOI,KAAP;AACD;;AAOD,WAASI,SAAT,GAAqB;AACnB,WAAOC,UAAP;AACD;;;;;AAnCKJ,mB,GAAgB,wB;AA4BhBI,gB,qCACsBJ,a;AAQtBK,c,GAAW;AACfd,kCADe;AAEfU,gCAFe;AAGfE;AAHe,O;;yBAMFE,Q","file":"postgres.js","sourcesContent":["/**\n * Postgres queries\n */\n\nconst ITEMID_FORMAT = 'FM99999999999999999999';\n\nfunction historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) {\n let time_expression = `clock / ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT to_char(itemid, '${ITEMID_FORMAT}') AS metric, ${time_expression} AS time, ${aggFunction}(value) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY 1, 2\n ORDER BY time ASC\n `;\n return query;\n}\n\nfunction trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) {\n let time_expression = `clock / ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT to_char(itemid, '${ITEMID_FORMAT}') AS metric, ${time_expression} AS time, ${aggFunction}(${valueColumn}) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY 1, 2\n ORDER BY time ASC\n `;\n return query;\n}\n\nconst TEST_QUERY = `\n SELECT to_char(itemid, '${ITEMID_FORMAT}') AS metric, clock AS time, value_avg AS value\n FROM trends_uint LIMIT 1\n`;\n\nfunction testQuery() {\n return TEST_QUERY;\n}\n\nconst postgres = {\n historyQuery,\n trendsQuery,\n testQuery\n};\n\nexport default postgres;\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js b/dist/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js new file mode 100644 index 0000000..0ef5348 --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js @@ -0,0 +1,282 @@ +'use strict'; + +System.register(['lodash', './mysql', './postgres', '../dbConnector'], function (_export, _context) { + "use strict"; + + var _, mysql, postgres, DBConnector, _createClass, _get, supportedDatabases, DEFAULT_QUERY_LIMIT, HISTORY_TO_TABLE_MAP, TREND_TO_TABLE_MAP, consolidateByFunc, consolidateByTrendColumns, SQLConnector; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + /////////////////////////////////////////////////////////////////////////////// + + function convertGrafanaTSResponse(time_series, items, addHostName) { + //uniqBy is needed to deduplicate + var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid'); + var grafanaSeries = _.map(time_series, function (series) { + var itemid = series.name; + var item = _.find(items, { 'itemid': itemid }); + var alias = item.name; + //only when actual multi hosts selected + if (_.keys(hosts).length > 1 && addHostName) { + var host = _.find(hosts, { 'hostid': item.hostid }); + alias = host.name + ": " + alias; + } + // CachingProxy deduplicates requests and returns one time series for equal queries. + // Clone is needed to prevent changing of series object shared between all targets. + var datapoints = _.cloneDeep(series.points); + return { + target: alias, + datapoints: datapoints + }; + }); + + return _.sortBy(grafanaSeries, 'target'); + } + + function compactSQLQuery(query) { + return query.replace(/\s+/g, ' '); + } + return { + setters: [function (_lodash) { + _ = _lodash.default; + }, function (_mysql) { + mysql = _mysql.default; + }, function (_postgres) { + postgres = _postgres.default; + }, function (_dbConnector) { + DBConnector = _dbConnector.default; + }], + execute: function () { + _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + _get = function get(object, property, receiver) { + if (object === null) object = Function.prototype; + var desc = Object.getOwnPropertyDescriptor(object, property); + + if (desc === undefined) { + var parent = Object.getPrototypeOf(object); + + if (parent === null) { + return undefined; + } else { + return get(parent, property, receiver); + } + } else if ("value" in desc) { + return desc.value; + } else { + var getter = desc.get; + + if (getter === undefined) { + return undefined; + } + + return getter.call(receiver); + } + }; + + supportedDatabases = { + mysql: 'mysql', + postgres: 'postgres' + }; + DEFAULT_QUERY_LIMIT = 10000; + HISTORY_TO_TABLE_MAP = { + '0': 'history', + '1': 'history_str', + '2': 'history_log', + '3': 'history_uint', + '4': 'history_text' + }; + TREND_TO_TABLE_MAP = { + '0': 'trends', + '3': 'trends_uint' + }; + consolidateByFunc = { + 'avg': 'AVG', + 'min': 'MIN', + 'max': 'MAX', + 'sum': 'SUM', + 'count': 'COUNT' + }; + consolidateByTrendColumns = { + 'avg': 'value_avg', + 'min': 'value_min', + 'max': 'value_max' + }; + + _export('SQLConnector', SQLConnector = function (_DBConnector) { + _inherits(SQLConnector, _DBConnector); + + function SQLConnector(options, backendSrv, datasourceSrv) { + _classCallCheck(this, SQLConnector); + + var _this = _possibleConstructorReturn(this, (SQLConnector.__proto__ || Object.getPrototypeOf(SQLConnector)).call(this, options, backendSrv, datasourceSrv)); + + _this.limit = options.limit || DEFAULT_QUERY_LIMIT; + _this.sqlDialect = null; + + _get(SQLConnector.prototype.__proto__ || Object.getPrototypeOf(SQLConnector.prototype), 'loadDBDataSource', _this).call(_this).then(function () { + return _this.loadSQLDialect(); + }); + return _this; + } + + _createClass(SQLConnector, [{ + key: 'loadSQLDialect', + value: function loadSQLDialect() { + if (this.datasourceType === supportedDatabases.postgres) { + this.sqlDialect = postgres; + } else { + this.sqlDialect = mysql; + } + } + }, { + key: 'testDataSource', + value: function testDataSource() { + var testQuery = this.sqlDialect.testQuery(); + return this.invokeSQLQuery(testQuery); + } + }, { + key: 'getHistory', + value: function getHistory(items, timeFrom, timeTill, options) { + var _this2 = this; + + var intervalMs = options.intervalMs, + consolidateBy = options.consolidateBy; + + var intervalSec = Math.ceil(intervalMs / 1000); + + consolidateBy = consolidateBy || 'avg'; + var aggFunction = consolidateByFunc[consolidateBy]; + + // Group items by value type and perform request for each value type + var grouped_items = _.groupBy(items, 'value_type'); + var promises = _.map(grouped_items, function (items, value_type) { + var itemids = _.map(items, 'itemid').join(', '); + var table = HISTORY_TO_TABLE_MAP[value_type]; + var query = _this2.sqlDialect.historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction); + + query = compactSQLQuery(query); + return _this2.invokeSQLQuery(query); + }); + + return Promise.all(promises).then(function (results) { + return _.flatten(results); + }); + } + }, { + key: 'getTrends', + value: function getTrends(items, timeFrom, timeTill, options) { + var _this3 = this; + + var intervalMs = options.intervalMs, + consolidateBy = options.consolidateBy; + + var intervalSec = Math.ceil(intervalMs / 1000); + + consolidateBy = consolidateBy || 'avg'; + var aggFunction = consolidateByFunc[consolidateBy]; + + // Group items by value type and perform request for each value type + var grouped_items = _.groupBy(items, 'value_type'); + var promises = _.map(grouped_items, function (items, value_type) { + var itemids = _.map(items, 'itemid').join(', '); + var table = TREND_TO_TABLE_MAP[value_type]; + var valueColumn = _.includes(['avg', 'min', 'max'], consolidateBy) ? consolidateBy : 'avg'; + valueColumn = consolidateByTrendColumns[valueColumn]; + var query = _this3.sqlDialect.trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn); + + query = compactSQLQuery(query); + return _this3.invokeSQLQuery(query); + }); + + return Promise.all(promises).then(function (results) { + return _.flatten(results); + }); + } + }, { + key: 'handleGrafanaTSResponse', + value: function handleGrafanaTSResponse(history, items) { + var addHostName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + + return convertGrafanaTSResponse(history, items, addHostName); + } + }, { + key: 'invokeSQLQuery', + value: function invokeSQLQuery(query) { + var queryDef = { + refId: 'A', + format: 'time_series', + datasourceId: this.datasourceId, + rawSql: query, + maxDataPoints: this.limit + }; + + return this.backendSrv.datasourceRequest({ + url: '/api/tsdb/query', + method: 'POST', + data: { + queries: [queryDef] + } + }).then(function (response) { + var results = response.data.results; + if (results['A']) { + return results['A'].series; + } else { + return null; + } + }); + } + }]); + + return SQLConnector; + }(DBConnector)); + + _export('SQLConnector', SQLConnector); + } + }; +}); +//# sourceMappingURL=sqlConnector.js.map diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js.map b/dist/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js.map new file mode 100644 index 0000000..c9e6ebe --- /dev/null +++ b/dist/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../../../../src/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js"],"names":["convertGrafanaTSResponse","time_series","items","addHostName","hosts","_","uniqBy","flatten","map","grafanaSeries","itemid","series","name","item","find","alias","keys","length","host","hostid","datapoints","cloneDeep","points","target","sortBy","compactSQLQuery","query","replace","mysql","postgres","DBConnector","supportedDatabases","DEFAULT_QUERY_LIMIT","HISTORY_TO_TABLE_MAP","TREND_TO_TABLE_MAP","consolidateByFunc","consolidateByTrendColumns","SQLConnector","options","backendSrv","datasourceSrv","limit","sqlDialect","then","loadSQLDialect","datasourceType","testQuery","invokeSQLQuery","timeFrom","timeTill","intervalMs","consolidateBy","intervalSec","Math","ceil","aggFunction","grouped_items","groupBy","promises","value_type","itemids","join","table","historyQuery","Promise","all","results","valueColumn","includes","trendsQuery","history","queryDef","refId","format","datasourceId","rawSql","maxDataPoints","datasourceRequest","url","method","data","queries","response"],"mappings":"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","file":"sqlConnector.js","sourcesContent":["import _ from 'lodash';\nimport mysql from './mysql';\nimport postgres from './postgres';\nimport DBConnector from '../dbConnector';\n\nconst supportedDatabases = {\n mysql: 'mysql',\n postgres: 'postgres'\n};\n\nconst DEFAULT_QUERY_LIMIT = 10000;\nconst HISTORY_TO_TABLE_MAP = {\n '0': 'history',\n '1': 'history_str',\n '2': 'history_log',\n '3': 'history_uint',\n '4': 'history_text'\n};\n\nconst TREND_TO_TABLE_MAP = {\n '0': 'trends',\n '3': 'trends_uint'\n};\n\nconst consolidateByFunc = {\n 'avg': 'AVG',\n 'min': 'MIN',\n 'max': 'MAX',\n 'sum': 'SUM',\n 'count': 'COUNT'\n};\n\nconst consolidateByTrendColumns = {\n 'avg': 'value_avg',\n 'min': 'value_min',\n 'max': 'value_max'\n};\n\nexport class SQLConnector extends DBConnector {\n constructor(options, backendSrv, datasourceSrv) {\n super(options, backendSrv, datasourceSrv);\n\n this.limit = options.limit || DEFAULT_QUERY_LIMIT;\n this.sqlDialect = null;\n\n super.loadDBDataSource()\n .then(() => this.loadSQLDialect());\n }\n\n loadSQLDialect() {\n if (this.datasourceType === supportedDatabases.postgres) {\n this.sqlDialect = postgres;\n } else {\n this.sqlDialect = mysql;\n }\n }\n\n /**\n * Try to invoke test query for one of Zabbix database tables.\n */\n testDataSource() {\n let testQuery = this.sqlDialect.testQuery();\n return this.invokeSQLQuery(testQuery);\n }\n\n getHistory(items, timeFrom, timeTill, options) {\n let {intervalMs, consolidateBy} = options;\n let intervalSec = Math.ceil(intervalMs / 1000);\n\n consolidateBy = consolidateBy || 'avg';\n let aggFunction = consolidateByFunc[consolidateBy];\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid').join(', ');\n let table = HISTORY_TO_TABLE_MAP[value_type];\n let query = this.sqlDialect.historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction);\n\n query = compactSQLQuery(query);\n return this.invokeSQLQuery(query);\n });\n\n return Promise.all(promises).then(results => {\n return _.flatten(results);\n });\n }\n\n getTrends(items, timeFrom, timeTill, options) {\n let { intervalMs, consolidateBy } = options;\n let intervalSec = Math.ceil(intervalMs / 1000);\n\n consolidateBy = consolidateBy || 'avg';\n let aggFunction = consolidateByFunc[consolidateBy];\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid').join(', ');\n let table = TREND_TO_TABLE_MAP[value_type];\n let valueColumn = _.includes(['avg', 'min', 'max'], consolidateBy) ? consolidateBy : 'avg';\n valueColumn = consolidateByTrendColumns[valueColumn];\n let query = this.sqlDialect.trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn);\n\n query = compactSQLQuery(query);\n return this.invokeSQLQuery(query);\n });\n\n return Promise.all(promises).then(results => {\n return _.flatten(results);\n });\n }\n\n handleGrafanaTSResponse(history, items, addHostName = true) {\n return convertGrafanaTSResponse(history, items, addHostName);\n }\n\n invokeSQLQuery(query) {\n let queryDef = {\n refId: 'A',\n format: 'time_series',\n datasourceId: this.datasourceId,\n rawSql: query,\n maxDataPoints: this.limit\n };\n\n return this.backendSrv.datasourceRequest({\n url: '/api/tsdb/query',\n method: 'POST',\n data: {\n queries: [queryDef],\n }\n })\n .then(response => {\n let results = response.data.results;\n if (results['A']) {\n return results['A'].series;\n } else {\n return null;\n }\n });\n }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n\nfunction convertGrafanaTSResponse(time_series, items, addHostName) {\n //uniqBy is needed to deduplicate\n var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid');\n let grafanaSeries = _.map(time_series, series => {\n let itemid = series.name;\n var item = _.find(items, {'itemid': itemid});\n var alias = item.name;\n //only when actual multi hosts selected\n if (_.keys(hosts).length > 1 && addHostName) {\n var host = _.find(hosts, {'hostid': item.hostid});\n alias = host.name + \": \" + alias;\n }\n // CachingProxy deduplicates requests and returns one time series for equal queries.\n // Clone is needed to prevent changing of series object shared between all targets.\n let datapoints = _.cloneDeep(series.points);\n return {\n target: alias,\n datapoints: datapoints\n };\n });\n\n return _.sortBy(grafanaSeries, 'target');\n}\n\nfunction compactSQLQuery(query) {\n return query.replace(/\\s+/g, ' ');\n}\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js.map b/dist/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js.map deleted file mode 100644 index 0fe4b44..0000000 --- a/dist/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["../../../../../src/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js"],"names":["convertGrafanaTSResponse","time_series","items","addHostName","hosts","_","uniqBy","flatten","map","grafanaSeries","itemid","series","name","item","find","alias","keys","length","host","hostid","datapoints","cloneDeep","points","target","sortBy","compactSQLQuery","query","replace","buildSQLHistoryQuery","itemids","table","timeFrom","timeTill","intervalSec","aggFunction","dialect","buildPostgresHistoryQuery","buildMysqlHistoryQuery","buildSQLTrendsQuery","valueColumn","buildPostgresTrendsQuery","buildMysqlTrendsQuery","time_expression","itemid_format","DEFAULT_QUERY_LIMIT","HISTORY_TO_TABLE_MAP","TREND_TO_TABLE_MAP","consolidateByFunc","consolidateByTrendColumns","ZabbixDBConnector","sqlDataSourceId","options","backendSrv","datasourceSrv","limit","loadSQLDataSource","datasourceId","ds","getAll","loadDatasource","then","sqlDataSourceType","meta","id","Promise","reject","testQuery","TEST_MYSQL_QUERY","TEST_POSTGRES_QUERY","invokeSQLQuery","intervalMs","consolidateBy","Math","ceil","grouped_items","groupBy","promises","value_type","join","all","results","includes","history","queryDef","refId","format","rawSql","maxDataPoints","datasourceRequest","url","method","data","queries","response"],"mappings":"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","file":"zabbixDBConnector.js","sourcesContent":["import _ from 'lodash';\n\nconst DEFAULT_QUERY_LIMIT = 10000;\nconst HISTORY_TO_TABLE_MAP = {\n '0': 'history',\n '1': 'history_str',\n '2': 'history_log',\n '3': 'history_uint',\n '4': 'history_text'\n};\n\nconst TREND_TO_TABLE_MAP = {\n '0': 'trends',\n '3': 'trends_uint'\n};\n\nconst consolidateByFunc = {\n 'avg': 'AVG',\n 'min': 'MIN',\n 'max': 'MAX',\n 'sum': 'SUM',\n 'count': 'COUNT'\n};\n\nconst consolidateByTrendColumns = {\n 'avg': 'value_avg',\n 'min': 'value_min',\n 'max': 'value_max'\n};\n\nexport class ZabbixDBConnector {\n\n constructor(sqlDataSourceId, options, backendSrv, datasourceSrv) {\n this.backendSrv = backendSrv;\n this.datasourceSrv = datasourceSrv;\n\n let limit = options.limit;\n this.sqlDataSourceId = sqlDataSourceId;\n this.limit = limit || DEFAULT_QUERY_LIMIT;\n\n this.loadSQLDataSource(sqlDataSourceId);\n }\n\n /**\n * Try to load DS with given id to check it's exist.\n * @param {*} datasourceId ID of SQL data source\n */\n loadSQLDataSource(datasourceId) {\n let ds = _.find(this.datasourceSrv.getAll(), {'id': datasourceId});\n if (ds) {\n return this.datasourceSrv.loadDatasource(ds.name)\n .then(ds => {\n this.sqlDataSourceType = ds.meta.id;\n return ds;\n });\n } else {\n return Promise.reject(`SQL Data Source with ID ${datasourceId} not found`);\n }\n }\n\n /**\n * Try to invoke test query for one of Zabbix database tables.\n */\n testSQLDataSource() {\n let testQuery = TEST_MYSQL_QUERY;\n if (this.sqlDataSourceType === 'postgres') {\n testQuery = TEST_POSTGRES_QUERY;\n }\n return this.invokeSQLQuery(testQuery);\n }\n\n getHistory(items, timeFrom, timeTill, options) {\n let {intervalMs, consolidateBy} = options;\n let intervalSec = Math.ceil(intervalMs / 1000);\n\n consolidateBy = consolidateBy || 'avg';\n let aggFunction = consolidateByFunc[consolidateBy];\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid').join(', ');\n let table = HISTORY_TO_TABLE_MAP[value_type];\n\n let dialect = this.sqlDataSourceType;\n let query = buildSQLHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, dialect);\n\n query = compactSQLQuery(query);\n return this.invokeSQLQuery(query);\n });\n\n return Promise.all(promises).then(results => {\n return _.flatten(results);\n });\n }\n\n getTrends(items, timeFrom, timeTill, options) {\n let {intervalMs, consolidateBy} = options;\n let intervalSec = Math.ceil(intervalMs / 1000);\n\n consolidateBy = consolidateBy || 'avg';\n let aggFunction = consolidateByFunc[consolidateBy];\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid').join(', ');\n let table = TREND_TO_TABLE_MAP[value_type];\n let valueColumn = _.includes(['avg', 'min', 'max'], consolidateBy) ? consolidateBy : 'avg';\n valueColumn = consolidateByTrendColumns[valueColumn];\n\n let dialect = this.sqlDataSourceType;\n let query = buildSQLTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn, dialect);\n\n query = compactSQLQuery(query);\n return this.invokeSQLQuery(query);\n });\n\n return Promise.all(promises).then(results => {\n return _.flatten(results);\n });\n }\n\n handleGrafanaTSResponse(history, items, addHostName = true) {\n return convertGrafanaTSResponse(history, items, addHostName);\n }\n\n invokeSQLQuery(query) {\n let queryDef = {\n refId: 'A',\n format: 'time_series',\n datasourceId: this.sqlDataSourceId,\n rawSql: query,\n maxDataPoints: this.limit\n };\n\n return this.backendSrv.datasourceRequest({\n url: '/api/tsdb/query',\n method: 'POST',\n data: {\n queries: [queryDef],\n }\n })\n .then(response => {\n let results = response.data.results;\n if (results['A']) {\n return results['A'].series;\n } else {\n return null;\n }\n });\n }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n\nfunction convertGrafanaTSResponse(time_series, items, addHostName) {\n var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid'); //uniqBy is needed to deduplicate\n let grafanaSeries = _.map(time_series, series => {\n let itemid = series.name;\n var item = _.find(items, {'itemid': itemid});\n var alias = item.name;\n if (_.keys(hosts).length > 1 && addHostName) { //only when actual multi hosts selected\n var host = _.find(hosts, {'hostid': item.hostid});\n alias = host.name + \": \" + alias;\n }\n // CachingProxy deduplicates requests and returns one time series for equal queries.\n // Clone is needed to prevent changing of series object shared between all targets.\n let datapoints = _.cloneDeep(series.points);\n return {\n target: alias,\n datapoints: datapoints\n };\n });\n\n return _.sortBy(grafanaSeries, 'target');\n}\n\nfunction compactSQLQuery(query) {\n return query.replace(/\\s+/g, ' ');\n}\n\nfunction buildSQLHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, dialect = 'mysql') {\n if (dialect === 'postgres') {\n return buildPostgresHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction);\n } else {\n return buildMysqlHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction);\n }\n}\n\nfunction buildSQLTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn, dialect = 'mysql') {\n if (dialect === 'postgres') {\n return buildPostgresTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn);\n } else {\n return buildMysqlTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn);\n }\n}\n\n///////////\n// MySQL //\n///////////\n\nfunction buildMysqlHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) {\n let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT itemid AS metric, ${time_expression} AS time_sec, ${aggFunction}(value) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY ${time_expression}, metric\n ORDER BY time_sec ASC\n `;\n return query;\n}\n\nfunction buildMysqlTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) {\n let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT itemid AS metric, ${time_expression} AS time_sec, ${aggFunction}(${valueColumn}) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY ${time_expression}, metric\n ORDER BY time_sec ASC\n `;\n return query;\n}\n\nconst TEST_MYSQL_QUERY = `SELECT itemid AS metric, clock AS time_sec, value_avg AS value FROM trends_uint LIMIT 1`;\n\n////////////////\n// PostgreSQL //\n////////////////\n\nconst itemid_format = 'FM99999999999999999999';\n\nfunction buildPostgresHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) {\n let time_expression = `clock / ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT to_char(itemid, '${itemid_format}') AS metric, ${time_expression} AS time, ${aggFunction}(value) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY 1, 2\n ORDER BY time ASC\n `;\n return query;\n}\n\nfunction buildPostgresTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) {\n let time_expression = `clock / ${intervalSec} * ${intervalSec}`;\n let query = `\n SELECT to_char(itemid, '${itemid_format}') AS metric, ${time_expression} AS time, ${aggFunction}(${valueColumn}) AS value\n FROM ${table}\n WHERE itemid IN (${itemids})\n AND clock > ${timeFrom} AND clock < ${timeTill}\n GROUP BY 1, 2\n ORDER BY time ASC\n `;\n return query;\n}\n\nconst TEST_POSTGRES_QUERY = `\n SELECT to_char(itemid, '${itemid_format}') AS metric, clock AS time, value_avg AS value\n FROM trends_uint LIMIT 1\n`;\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js b/dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js deleted file mode 100644 index f6f1280..0000000 --- a/dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js +++ /dev/null @@ -1,106 +0,0 @@ -"use strict"; - -System.register([], function (_export, _context) { - "use strict"; - - var _createClass, ZabbixConnector; - - function _classCallCheck(instance, Constructor) { - if (!(instance instanceof Constructor)) { - throw new TypeError("Cannot call a class as a function"); - } - } - - return { - setters: [], - execute: function () { - _createClass = function () { - function defineProperties(target, props) { - for (var i = 0; i < props.length; i++) { - var descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ("value" in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); - } - } - - return function (Constructor, protoProps, staticProps) { - if (protoProps) defineProperties(Constructor.prototype, protoProps); - if (staticProps) defineProperties(Constructor, staticProps); - return Constructor; - }; - }(); - - ZabbixConnector = function () { - function ZabbixConnector() { - _classCallCheck(this, ZabbixConnector); - } - - _createClass(ZabbixConnector, [{ - key: "testDataSource", - value: function testDataSource() {} - }, { - key: "getHistory", - value: function getHistory() {} - }, { - key: "getTrends", - value: function getTrends() {} - }, { - key: "getGroups", - value: function getGroups() {} - }, { - key: "getHosts", - value: function getHosts() {} - }, { - key: "getApps", - value: function getApps() {} - }, { - key: "getItems", - value: function getItems() {} - }, { - key: "getItemsByIDs", - value: function getItemsByIDs() {} - }, { - key: "getMacros", - value: function getMacros() {} - }, { - key: "getGlobalMacros", - value: function getGlobalMacros() {} - }, { - key: "getLastValue", - value: function getLastValue() {} - }, { - key: "getTriggers", - value: function getTriggers() {} - }, { - key: "getEvents", - value: function getEvents() {} - }, { - key: "getAlerts", - value: function getAlerts() {} - }, { - key: "getHostAlerts", - value: function getHostAlerts() {} - }, { - key: "getAcknowledges", - value: function getAcknowledges() {} - }, { - key: "getITService", - value: function getITService() {} - }, { - key: "getSLA", - value: function getSLA() {} - }, { - key: "getVersion", - value: function getVersion() {} - }]); - - return ZabbixConnector; - }(); - - _export("default", ZabbixConnector); - } - }; -}); -//# sourceMappingURL=zabbixConnector.js.map diff --git a/dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js.map b/dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js.map deleted file mode 100644 index e79a83b..0000000 --- a/dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["../../../../src/datasource-zabbix/zabbix/connectors/zabbixConnector.js"],"names":["ZabbixConnector"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIqBA,qB;AAEnB,mCAAc;AAAA;AAAE;;;;2CAEC,CAAE;;;uCAEN,CAAE;;;sCAEH,CAAE;;;sCAEF,CAAE;;;qCAEH,CAAE;;;oCAEH,CAAE;;;qCAED,CAAE;;;0CAEG,CAAE;;;sCAEN,CAAE;;;4CAEI,CAAE;;;yCAEL,CAAE;;;wCAEH,CAAE;;;sCAEJ,CAAE;;;sCAEF,CAAE;;;0CAEE,CAAE;;;4CAEA,CAAE;;;yCAEL,CAAE;;;mCAER,CAAE;;;uCAEE,CAAE;;;;;;yBAxCIA,e","file":"zabbixConnector.js","sourcesContent":["/**\n * Base class for all Zabbix connectors\n */\n\nexport default class ZabbixConnector {\n\n constructor() {}\n\n testDataSource() {}\n\n getHistory() {}\n\n getTrends() {}\n\n getGroups() {}\n\n getHosts() {}\n\n getApps() {}\n\n getItems() {}\n\n getItemsByIDs() {}\n\n getMacros() {}\n\n getGlobalMacros() {}\n\n getLastValue() {}\n\n getTriggers() {}\n\n getEvents() {}\n\n getAlerts() {}\n\n getHostAlerts() {}\n\n getAcknowledges() {}\n\n getITService() {}\n\n getSLA() {}\n\n getVersion() {}\n}\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js b/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js index c73b79c..51cf203 100644 --- a/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js +++ b/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js @@ -94,8 +94,6 @@ System.register(['lodash', '../../../utils', './zabbixAPICore'], function (_expo }(); _export('ZabbixAPIConnector', ZabbixAPIConnector = function () { - - /** @ngInject */ function ZabbixAPIConnector(api_url, username, password, basicAuth, withCredentials, backendSrv) { _classCallCheck(this, ZabbixAPIConnector); diff --git a/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js.map b/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js.map index 61cbc28..e55e78e 100644 --- a/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js.map +++ b/dist/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js.map @@ -1 +1 @@ -{"version":3,"sources":["../../../../../src/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js"],"names":["filterTriggersByAcknowledge","triggers","acknowledged","_","filter","trigger","lastEvent","isNotAuthorized","message","utils","ZabbixAPICore","ZabbixAPIConnector","api_url","username","password","basicAuth","withCredentials","backendSrv","url","auth","requestOptions","loginPromise","loginErrorCount","maxLoginAttempts","zabbixAPICore","getTrend","getTrend_ZBXNEXT1193","method","params","request","catch","error","data","loginOnce","then","statusText","Promise","reject","resolve","login","getVersion","eventid","eventids","output","sortfield","real_hosts","groupids","hostids","appids","itemtype","webitems","selectHosts","applicationids","value_type","expandItems","itemids","globalmacro","itemid","items","length","lastvalue","timeFrom","timeTill","grouped_items","groupBy","promises","map","history","sortorder","time_from","time_till","all","flatten","trend","self","serviceids","timeRange","timeTo","intervals","from","to","options","showTriggers","maintenance","expandDescription","expandData","expandComment","monitored","skipDependent","value","selectGroups","selectItems","selectLastEvent","selectTags","lastChangeSince","lastChangeTill","objectids","showEvents","select_acknowledges","preservekeys","events","event","acknowledges","minSeverity","count","min_severity","countOutput"],"mappings":"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","file":"zabbixAPIConnector.js","sourcesContent":["import _ from 'lodash';\nimport * as utils from '../../../utils';\nimport { ZabbixAPICore } from './zabbixAPICore';\n\n/**\n * Zabbix API Wrapper.\n * Creates Zabbix API instance with given parameters (url, credentials and other).\n * Wraps API calls and provides high-level methods.\n */\nexport class ZabbixAPIConnector {\n\n /** @ngInject */\n constructor(api_url, username, password, basicAuth, withCredentials, backendSrv) {\n this.url = api_url;\n this.username = username;\n this.password = password;\n this.auth = \"\";\n\n this.requestOptions = {\n basicAuth: basicAuth,\n withCredentials: withCredentials\n };\n\n this.loginPromise = null;\n this.loginErrorCount = 0;\n this.maxLoginAttempts = 3;\n\n this.zabbixAPICore = new ZabbixAPICore(backendSrv);\n\n this.getTrend = this.getTrend_ZBXNEXT1193;\n //getTrend = getTrend_30;\n }\n\n //////////////////////////\n // Core method wrappers //\n //////////////////////////\n\n request(method, params) {\n return this.zabbixAPICore.request(this.url, method, params, this.requestOptions, this.auth)\n .catch(error => {\n if (isNotAuthorized(error.data)) {\n // Handle auth errors\n this.loginErrorCount++;\n if (this.loginErrorCount > this.maxLoginAttempts) {\n this.loginErrorCount = 0;\n return null;\n } else {\n return this.loginOnce()\n .then(() => this.request(method, params));\n }\n } else {\n // Handle API errors\n let message = error.data ? error.data : error.statusText;\n return Promise.reject(message);\n }\n });\n }\n\n /**\n * When API unauthenticated or auth token expired each request produce login()\n * call. But auth token is common to all requests. This function wraps login() method\n * and call it once. If login() already called just wait for it (return its promise).\n * @return login promise\n */\n loginOnce() {\n if (!this.loginPromise) {\n this.loginPromise = Promise.resolve(\n this.login().then(auth => {\n this.auth = auth;\n this.loginPromise = null;\n return auth;\n })\n );\n }\n return this.loginPromise;\n }\n\n /**\n * Get authentication token.\n */\n login() {\n return this.zabbixAPICore.login(this.url, this.username, this.password, this.requestOptions);\n }\n\n /**\n * Get Zabbix API version\n */\n getVersion() {\n return this.zabbixAPICore.getVersion(this.url, this.requestOptions);\n }\n\n ////////////////////////////////\n // Zabbix API method wrappers //\n ////////////////////////////////\n\n acknowledgeEvent(eventid, message) {\n var params = {\n eventids: eventid,\n message: message\n };\n\n return this.request('event.acknowledge', params);\n }\n\n getGroups() {\n var params = {\n output: ['name'],\n sortfield: 'name',\n real_hosts: true\n };\n\n return this.request('hostgroup.get', params);\n }\n\n getHosts(groupids) {\n var params = {\n output: ['name', 'host'],\n sortfield: 'name'\n };\n if (groupids) {\n params.groupids = groupids;\n }\n\n return this.request('host.get', params);\n }\n\n getApps(hostids) {\n var params = {\n output: 'extend',\n hostids: hostids\n };\n\n return this.request('application.get', params);\n }\n\n /**\n * Get Zabbix items\n * @param {[type]} hostids host ids\n * @param {[type]} appids application ids\n * @param {String} itemtype 'num' or 'text'\n * @return {[type]} array of items\n */\n getItems(hostids, appids, itemtype) {\n var params = {\n output: [\n 'name', 'key_',\n 'value_type',\n 'hostid',\n 'status',\n 'state'\n ],\n sortfield: 'name',\n webitems: true,\n filter: {},\n selectHosts: ['hostid', 'name']\n };\n if (hostids) {\n params.hostids = hostids;\n }\n if (appids) {\n params.applicationids = appids;\n }\n if (itemtype === 'num') {\n // Return only numeric metrics\n params.filter.value_type = [0, 3];\n }\n if (itemtype === 'text') {\n // Return only text metrics\n params.filter.value_type = [1, 2, 4];\n }\n\n return this.request('item.get', params)\n .then(utils.expandItems);\n }\n\n getItemsByIDs(itemids) {\n var params = {\n itemids: itemids,\n output: [\n 'name', 'key_',\n 'value_type',\n 'hostid',\n 'status',\n 'state'\n ],\n webitems: true,\n selectHosts: ['hostid', 'name']\n };\n\n return this.request('item.get', params)\n .then(utils.expandItems);\n }\n\n getMacros(hostids) {\n var params = {\n output: 'extend',\n hostids: hostids\n };\n\n return this.request('usermacro.get', params);\n }\n\n getGlobalMacros() {\n var params = {\n output: 'extend',\n globalmacro: true\n };\n\n return this.request('usermacro.get', params);\n }\n\n getLastValue(itemid) {\n var params = {\n output: ['lastvalue'],\n itemids: itemid\n };\n return this.request('item.get', params)\n .then(items => items.length ? items[0].lastvalue : null);\n }\n\n /**\n * Perform history query from Zabbix API\n *\n * @param {Array} items Array of Zabbix item objects\n * @param {Number} timeFrom Time in seconds\n * @param {Number} timeTill Time in seconds\n * @return {Array} Array of Zabbix history objects\n */\n getHistory(items, timeFrom, timeTill) {\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid');\n let params = {\n output: 'extend',\n history: value_type,\n itemids: itemids,\n sortfield: 'clock',\n sortorder: 'ASC',\n time_from: timeFrom\n };\n\n // Relative queries (e.g. last hour) don't include an end time\n if (timeTill) {\n params.time_till = timeTill;\n }\n\n return this.request('history.get', params);\n });\n\n return Promise.all(promises).then(_.flatten);\n }\n\n /**\n * Perform trends query from Zabbix API\n * Use trends api extension from ZBXNEXT-1193 patch.\n *\n * @param {Array} items Array of Zabbix item objects\n * @param {Number} time_from Time in seconds\n * @param {Number} time_till Time in seconds\n * @return {Array} Array of Zabbix trend objects\n */\n getTrend_ZBXNEXT1193(items, timeFrom, timeTill) {\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid');\n let params = {\n output: 'extend',\n trend: value_type,\n itemids: itemids,\n sortfield: 'clock',\n sortorder: 'ASC',\n time_from: timeFrom\n };\n\n // Relative queries (e.g. last hour) don't include an end time\n if (timeTill) {\n params.time_till = timeTill;\n }\n\n return this.request('trend.get', params);\n });\n\n return Promise.all(promises).then(_.flatten);\n }\n\n getTrend_30(items, time_from, time_till, value_type) {\n var self = this;\n var itemids = _.map(items, 'itemid');\n\n var params = {\n output: [\"itemid\",\n \"clock\",\n value_type\n ],\n itemids: itemids,\n time_from: time_from\n };\n\n // Relative queries (e.g. last hour) don't include an end time\n if (time_till) {\n params.time_till = time_till;\n }\n\n return self.request('trend.get', params);\n }\n\n getITService(serviceids) {\n var params = {\n output: 'extend',\n serviceids: serviceids\n };\n return this.request('service.get', params);\n }\n\n getSLA(serviceids, timeRange) {\n let [timeFrom, timeTo] = timeRange;\n var params = {\n serviceids: serviceids,\n intervals: [{\n from: timeFrom,\n to: timeTo\n }]\n };\n return this.request('service.getsla', params);\n }\n\n getTriggers(groupids, hostids, applicationids, options) {\n let {showTriggers, maintenance, timeFrom, timeTo} = options;\n\n let params = {\n output: 'extend',\n groupids: groupids,\n hostids: hostids,\n applicationids: applicationids,\n expandDescription: true,\n expandData: true,\n expandComment: true,\n monitored: true,\n skipDependent: true,\n //only_true: true,\n filter: {\n value: 1\n },\n selectGroups: ['name'],\n selectHosts: ['name', 'host', 'maintenance_status'],\n selectItems: ['name', 'key_', 'lastvalue'],\n selectLastEvent: 'extend',\n selectTags: 'extend'\n };\n\n if (showTriggers) {\n params.filter.value = showTriggers;\n }\n\n if (maintenance) {\n params.maintenance = true;\n }\n\n if (timeFrom || timeTo) {\n params.lastChangeSince = timeFrom;\n params.lastChangeTill = timeTo;\n }\n\n return this.request('trigger.get', params);\n }\n\n getEvents(objectids, timeFrom, timeTo, showEvents) {\n var params = {\n output: 'extend',\n time_from: timeFrom,\n time_till: timeTo,\n objectids: objectids,\n select_acknowledges: 'extend',\n selectHosts: 'extend',\n value: showEvents\n };\n\n return this.request('event.get', params);\n }\n\n getAcknowledges(eventids) {\n var params = {\n output: 'extend',\n eventids: eventids,\n preservekeys: true,\n select_acknowledges: 'extend',\n sortfield: 'clock',\n sortorder: 'DESC'\n };\n\n return this.request('event.get', params)\n .then(events => {\n return _.filter(events, (event) => event.acknowledges.length);\n });\n }\n\n getAlerts(itemids, timeFrom, timeTo) {\n var params = {\n output: 'extend',\n itemids: itemids,\n expandDescription: true,\n expandData: true,\n expandComment: true,\n monitored: true,\n skipDependent: true,\n //only_true: true,\n // filter: {\n // value: 1\n // },\n selectLastEvent: 'extend'\n };\n\n if (timeFrom || timeTo) {\n params.lastChangeSince = timeFrom;\n params.lastChangeTill = timeTo;\n }\n\n return this.request('trigger.get', params);\n }\n\n getHostAlerts(hostids, applicationids, options) {\n let {minSeverity, acknowledged, count, timeFrom, timeTo} = options;\n let params = {\n output: 'extend',\n hostids: hostids,\n min_severity: minSeverity,\n filter: { value: 1 },\n expandDescription: true,\n expandData: true,\n expandComment: true,\n monitored: true,\n skipDependent: true,\n selectLastEvent: 'extend',\n selectGroups: 'extend',\n selectHosts: ['host', 'name']\n };\n\n if (count && acknowledged !== 0 && acknowledged !== 1) {\n params.countOutput = true;\n }\n\n if (applicationids && applicationids.length) {\n params.applicationids = applicationids;\n }\n\n if (timeFrom || timeTo) {\n params.lastChangeSince = timeFrom;\n params.lastChangeTill = timeTo;\n }\n\n return this.request('trigger.get', params)\n .then((triggers) => {\n if (!count || acknowledged === 0 || acknowledged === 1) {\n triggers = filterTriggersByAcknowledge(triggers, acknowledged);\n if (count) {\n triggers = triggers.length;\n }\n }\n return triggers;\n });\n }\n}\n\nfunction filterTriggersByAcknowledge(triggers, acknowledged) {\n if (acknowledged === 0) {\n return _.filter(triggers, (trigger) => trigger.lastEvent.acknowledged === \"0\");\n } else if (acknowledged === 1) {\n return _.filter(triggers, (trigger) => trigger.lastEvent.acknowledged === \"1\");\n } else {\n return triggers;\n }\n}\n\nfunction isNotAuthorized(message) {\n return (\n message === \"Session terminated, re-login, please.\" ||\n message === \"Not authorised.\" ||\n message === \"Not authorized.\"\n );\n}\n"]} \ No newline at end of file +{"version":3,"sources":["../../../../../src/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.js"],"names":["filterTriggersByAcknowledge","triggers","acknowledged","_","filter","trigger","lastEvent","isNotAuthorized","message","utils","ZabbixAPICore","ZabbixAPIConnector","api_url","username","password","basicAuth","withCredentials","backendSrv","url","auth","requestOptions","loginPromise","loginErrorCount","maxLoginAttempts","zabbixAPICore","getTrend","getTrend_ZBXNEXT1193","method","params","request","catch","error","data","loginOnce","then","statusText","Promise","reject","resolve","login","getVersion","eventid","eventids","output","sortfield","real_hosts","groupids","hostids","appids","itemtype","webitems","selectHosts","applicationids","value_type","expandItems","itemids","globalmacro","itemid","items","length","lastvalue","timeFrom","timeTill","grouped_items","groupBy","promises","map","history","sortorder","time_from","time_till","all","flatten","trend","self","serviceids","timeRange","timeTo","intervals","from","to","options","showTriggers","maintenance","expandDescription","expandData","expandComment","monitored","skipDependent","value","selectGroups","selectItems","selectLastEvent","selectTags","lastChangeSince","lastChangeTill","objectids","showEvents","select_acknowledges","preservekeys","events","event","acknowledges","minSeverity","count","min_severity","countOutput"],"mappings":"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","file":"zabbixAPIConnector.js","sourcesContent":["import _ from 'lodash';\nimport * as utils from '../../../utils';\nimport { ZabbixAPICore } from './zabbixAPICore';\n\n/**\n * Zabbix API Wrapper.\n * Creates Zabbix API instance with given parameters (url, credentials and other).\n * Wraps API calls and provides high-level methods.\n */\nexport class ZabbixAPIConnector {\n constructor(api_url, username, password, basicAuth, withCredentials, backendSrv) {\n this.url = api_url;\n this.username = username;\n this.password = password;\n this.auth = \"\";\n\n this.requestOptions = {\n basicAuth: basicAuth,\n withCredentials: withCredentials\n };\n\n this.loginPromise = null;\n this.loginErrorCount = 0;\n this.maxLoginAttempts = 3;\n\n this.zabbixAPICore = new ZabbixAPICore(backendSrv);\n\n this.getTrend = this.getTrend_ZBXNEXT1193;\n //getTrend = getTrend_30;\n }\n\n //////////////////////////\n // Core method wrappers //\n //////////////////////////\n\n request(method, params) {\n return this.zabbixAPICore.request(this.url, method, params, this.requestOptions, this.auth)\n .catch(error => {\n if (isNotAuthorized(error.data)) {\n // Handle auth errors\n this.loginErrorCount++;\n if (this.loginErrorCount > this.maxLoginAttempts) {\n this.loginErrorCount = 0;\n return null;\n } else {\n return this.loginOnce()\n .then(() => this.request(method, params));\n }\n } else {\n // Handle API errors\n let message = error.data ? error.data : error.statusText;\n return Promise.reject(message);\n }\n });\n }\n\n /**\n * When API unauthenticated or auth token expired each request produce login()\n * call. But auth token is common to all requests. This function wraps login() method\n * and call it once. If login() already called just wait for it (return its promise).\n * @return login promise\n */\n loginOnce() {\n if (!this.loginPromise) {\n this.loginPromise = Promise.resolve(\n this.login().then(auth => {\n this.auth = auth;\n this.loginPromise = null;\n return auth;\n })\n );\n }\n return this.loginPromise;\n }\n\n /**\n * Get authentication token.\n */\n login() {\n return this.zabbixAPICore.login(this.url, this.username, this.password, this.requestOptions);\n }\n\n /**\n * Get Zabbix API version\n */\n getVersion() {\n return this.zabbixAPICore.getVersion(this.url, this.requestOptions);\n }\n\n ////////////////////////////////\n // Zabbix API method wrappers //\n ////////////////////////////////\n\n acknowledgeEvent(eventid, message) {\n var params = {\n eventids: eventid,\n message: message\n };\n\n return this.request('event.acknowledge', params);\n }\n\n getGroups() {\n var params = {\n output: ['name'],\n sortfield: 'name',\n real_hosts: true\n };\n\n return this.request('hostgroup.get', params);\n }\n\n getHosts(groupids) {\n var params = {\n output: ['name', 'host'],\n sortfield: 'name'\n };\n if (groupids) {\n params.groupids = groupids;\n }\n\n return this.request('host.get', params);\n }\n\n getApps(hostids) {\n var params = {\n output: 'extend',\n hostids: hostids\n };\n\n return this.request('application.get', params);\n }\n\n /**\n * Get Zabbix items\n * @param {[type]} hostids host ids\n * @param {[type]} appids application ids\n * @param {String} itemtype 'num' or 'text'\n * @return {[type]} array of items\n */\n getItems(hostids, appids, itemtype) {\n var params = {\n output: [\n 'name', 'key_',\n 'value_type',\n 'hostid',\n 'status',\n 'state'\n ],\n sortfield: 'name',\n webitems: true,\n filter: {},\n selectHosts: ['hostid', 'name']\n };\n if (hostids) {\n params.hostids = hostids;\n }\n if (appids) {\n params.applicationids = appids;\n }\n if (itemtype === 'num') {\n // Return only numeric metrics\n params.filter.value_type = [0, 3];\n }\n if (itemtype === 'text') {\n // Return only text metrics\n params.filter.value_type = [1, 2, 4];\n }\n\n return this.request('item.get', params)\n .then(utils.expandItems);\n }\n\n getItemsByIDs(itemids) {\n var params = {\n itemids: itemids,\n output: [\n 'name', 'key_',\n 'value_type',\n 'hostid',\n 'status',\n 'state'\n ],\n webitems: true,\n selectHosts: ['hostid', 'name']\n };\n\n return this.request('item.get', params)\n .then(utils.expandItems);\n }\n\n getMacros(hostids) {\n var params = {\n output: 'extend',\n hostids: hostids\n };\n\n return this.request('usermacro.get', params);\n }\n\n getGlobalMacros() {\n var params = {\n output: 'extend',\n globalmacro: true\n };\n\n return this.request('usermacro.get', params);\n }\n\n getLastValue(itemid) {\n var params = {\n output: ['lastvalue'],\n itemids: itemid\n };\n return this.request('item.get', params)\n .then(items => items.length ? items[0].lastvalue : null);\n }\n\n /**\n * Perform history query from Zabbix API\n *\n * @param {Array} items Array of Zabbix item objects\n * @param {Number} timeFrom Time in seconds\n * @param {Number} timeTill Time in seconds\n * @return {Array} Array of Zabbix history objects\n */\n getHistory(items, timeFrom, timeTill) {\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid');\n let params = {\n output: 'extend',\n history: value_type,\n itemids: itemids,\n sortfield: 'clock',\n sortorder: 'ASC',\n time_from: timeFrom\n };\n\n // Relative queries (e.g. last hour) don't include an end time\n if (timeTill) {\n params.time_till = timeTill;\n }\n\n return this.request('history.get', params);\n });\n\n return Promise.all(promises).then(_.flatten);\n }\n\n /**\n * Perform trends query from Zabbix API\n * Use trends api extension from ZBXNEXT-1193 patch.\n *\n * @param {Array} items Array of Zabbix item objects\n * @param {Number} time_from Time in seconds\n * @param {Number} time_till Time in seconds\n * @return {Array} Array of Zabbix trend objects\n */\n getTrend_ZBXNEXT1193(items, timeFrom, timeTill) {\n\n // Group items by value type and perform request for each value type\n let grouped_items = _.groupBy(items, 'value_type');\n let promises = _.map(grouped_items, (items, value_type) => {\n let itemids = _.map(items, 'itemid');\n let params = {\n output: 'extend',\n trend: value_type,\n itemids: itemids,\n sortfield: 'clock',\n sortorder: 'ASC',\n time_from: timeFrom\n };\n\n // Relative queries (e.g. last hour) don't include an end time\n if (timeTill) {\n params.time_till = timeTill;\n }\n\n return this.request('trend.get', params);\n });\n\n return Promise.all(promises).then(_.flatten);\n }\n\n getTrend_30(items, time_from, time_till, value_type) {\n var self = this;\n var itemids = _.map(items, 'itemid');\n\n var params = {\n output: [\"itemid\",\n \"clock\",\n value_type\n ],\n itemids: itemids,\n time_from: time_from\n };\n\n // Relative queries (e.g. last hour) don't include an end time\n if (time_till) {\n params.time_till = time_till;\n }\n\n return self.request('trend.get', params);\n }\n\n getITService(serviceids) {\n var params = {\n output: 'extend',\n serviceids: serviceids\n };\n return this.request('service.get', params);\n }\n\n getSLA(serviceids, timeRange) {\n let [timeFrom, timeTo] = timeRange;\n var params = {\n serviceids: serviceids,\n intervals: [{\n from: timeFrom,\n to: timeTo\n }]\n };\n return this.request('service.getsla', params);\n }\n\n getTriggers(groupids, hostids, applicationids, options) {\n let {showTriggers, maintenance, timeFrom, timeTo} = options;\n\n let params = {\n output: 'extend',\n groupids: groupids,\n hostids: hostids,\n applicationids: applicationids,\n expandDescription: true,\n expandData: true,\n expandComment: true,\n monitored: true,\n skipDependent: true,\n //only_true: true,\n filter: {\n value: 1\n },\n selectGroups: ['name'],\n selectHosts: ['name', 'host', 'maintenance_status'],\n selectItems: ['name', 'key_', 'lastvalue'],\n selectLastEvent: 'extend',\n selectTags: 'extend'\n };\n\n if (showTriggers) {\n params.filter.value = showTriggers;\n }\n\n if (maintenance) {\n params.maintenance = true;\n }\n\n if (timeFrom || timeTo) {\n params.lastChangeSince = timeFrom;\n params.lastChangeTill = timeTo;\n }\n\n return this.request('trigger.get', params);\n }\n\n getEvents(objectids, timeFrom, timeTo, showEvents) {\n var params = {\n output: 'extend',\n time_from: timeFrom,\n time_till: timeTo,\n objectids: objectids,\n select_acknowledges: 'extend',\n selectHosts: 'extend',\n value: showEvents\n };\n\n return this.request('event.get', params);\n }\n\n getAcknowledges(eventids) {\n var params = {\n output: 'extend',\n eventids: eventids,\n preservekeys: true,\n select_acknowledges: 'extend',\n sortfield: 'clock',\n sortorder: 'DESC'\n };\n\n return this.request('event.get', params)\n .then(events => {\n return _.filter(events, (event) => event.acknowledges.length);\n });\n }\n\n getAlerts(itemids, timeFrom, timeTo) {\n var params = {\n output: 'extend',\n itemids: itemids,\n expandDescription: true,\n expandData: true,\n expandComment: true,\n monitored: true,\n skipDependent: true,\n //only_true: true,\n // filter: {\n // value: 1\n // },\n selectLastEvent: 'extend'\n };\n\n if (timeFrom || timeTo) {\n params.lastChangeSince = timeFrom;\n params.lastChangeTill = timeTo;\n }\n\n return this.request('trigger.get', params);\n }\n\n getHostAlerts(hostids, applicationids, options) {\n let {minSeverity, acknowledged, count, timeFrom, timeTo} = options;\n let params = {\n output: 'extend',\n hostids: hostids,\n min_severity: minSeverity,\n filter: { value: 1 },\n expandDescription: true,\n expandData: true,\n expandComment: true,\n monitored: true,\n skipDependent: true,\n selectLastEvent: 'extend',\n selectGroups: 'extend',\n selectHosts: ['host', 'name']\n };\n\n if (count && acknowledged !== 0 && acknowledged !== 1) {\n params.countOutput = true;\n }\n\n if (applicationids && applicationids.length) {\n params.applicationids = applicationids;\n }\n\n if (timeFrom || timeTo) {\n params.lastChangeSince = timeFrom;\n params.lastChangeTill = timeTo;\n }\n\n return this.request('trigger.get', params)\n .then((triggers) => {\n if (!count || acknowledged === 0 || acknowledged === 1) {\n triggers = filterTriggersByAcknowledge(triggers, acknowledged);\n if (count) {\n triggers = triggers.length;\n }\n }\n return triggers;\n });\n }\n}\n\nfunction filterTriggersByAcknowledge(triggers, acknowledged) {\n if (acknowledged === 0) {\n return _.filter(triggers, (trigger) => trigger.lastEvent.acknowledged === \"0\");\n } else if (acknowledged === 1) {\n return _.filter(triggers, (trigger) => trigger.lastEvent.acknowledged === \"1\");\n } else {\n return triggers;\n }\n}\n\nfunction isNotAuthorized(message) {\n return (\n message === \"Session terminated, re-login, please.\" ||\n message === \"Not authorised.\" ||\n message === \"Not authorized.\"\n );\n}\n"]} \ No newline at end of file diff --git a/dist/datasource-zabbix/zabbix/zabbix.js b/dist/datasource-zabbix/zabbix/zabbix.js index 913b244..9fd66f7 100644 --- a/dist/datasource-zabbix/zabbix/zabbix.js +++ b/dist/datasource-zabbix/zabbix/zabbix.js @@ -1,9 +1,9 @@ 'use strict'; -System.register(['lodash', '../utils', './connectors/zabbix_api/zabbixAPIConnector', './connectors/sql/zabbixDBConnector', './proxy/cachingProxy'], function (_export, _context) { +System.register(['lodash', '../utils', '../responseHandler', './connectors/zabbix_api/zabbixAPIConnector', './connectors/sql/sqlConnector', './proxy/cachingProxy'], function (_export, _context) { "use strict"; - var _, utils, ZabbixAPIConnector, ZabbixDBConnector, CachingProxy, _slicedToArray, _createClass, REQUESTS_TO_PROXYFY, REQUESTS_TO_CACHE, REQUESTS_TO_BIND, Zabbix; + var _, utils, responseHandler, ZabbixAPIConnector, SQLConnector, CachingProxy, _slicedToArray, _createClass, REQUESTS_TO_PROXYFY, REQUESTS_TO_CACHE, REQUESTS_TO_BIND, Zabbix; function _toConsumableArray(arr) { if (Array.isArray(arr)) { @@ -91,10 +91,12 @@ System.register(['lodash', '../utils', './connectors/zabbix_api/zabbixAPIConnect _ = _lodash.default; }, function (_utils) { utils = _utils; + }, function (_responseHandler) { + responseHandler = _responseHandler.default; }, function (_connectorsZabbix_apiZabbixAPIConnector) { ZabbixAPIConnector = _connectorsZabbix_apiZabbixAPIConnector.ZabbixAPIConnector; - }, function (_connectorsSqlZabbixDBConnector) { - ZabbixDBConnector = _connectorsSqlZabbixDBConnector.ZabbixDBConnector; + }, function (_connectorsSqlSqlConnector) { + SQLConnector = _connectorsSqlSqlConnector.SQLConnector; }, function (_proxyCachingProxy) { CachingProxy = _proxyCachingProxy.CachingProxy; }], @@ -157,23 +159,24 @@ System.register(['lodash', '../utils', './connectors/zabbix_api/zabbixAPIConnect REQUESTS_TO_PROXYFY = ['getHistory', 'getTrend', 'getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs', 'getEvents', 'getAlerts', 'getHostAlerts', 'getAcknowledges', 'getITService', 'getSLA', 'getVersion']; REQUESTS_TO_CACHE = ['getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs', 'getITService']; - REQUESTS_TO_BIND = ['getHistory', 'getTrend', 'getMacros', 'getItemsByIDs', 'getEvents', 'getAlerts', 'getHostAlerts', 'getAcknowledges', 'getITService', 'getSLA', 'getVersion', 'login']; + REQUESTS_TO_BIND = ['getHistory', 'getTrend', 'getMacros', 'getItemsByIDs', 'getEvents', 'getAlerts', 'getHostAlerts', 'getAcknowledges', 'getITService', 'getVersion', 'login']; _export('Zabbix', Zabbix = function () { - - /** @ngInject */ - function Zabbix(url, options, backendSrv, datasourceSrv) { + function Zabbix(options, backendSrv, datasourceSrv) { _classCallCheck(this, Zabbix); - var username = options.username, + var url = options.url, + username = options.username, password = options.password, basicAuth = options.basicAuth, withCredentials = options.withCredentials, cacheTTL = options.cacheTTL, enableDirectDBConnection = options.enableDirectDBConnection, - sqlDatasourceId = options.sqlDatasourceId; + datasourceId = options.datasourceId; + this.enableDirectDBConnection = enableDirectDBConnection; + // Initialize caching proxy for requests var cacheOptions = { enabled: true, @@ -184,7 +187,8 @@ System.register(['lodash', '../utils', './connectors/zabbix_api/zabbixAPIConnect this.zabbixAPI = new ZabbixAPIConnector(url, username, password, basicAuth, withCredentials, backendSrv); if (enableDirectDBConnection) { - this.dbConnector = new ZabbixDBConnector(sqlDatasourceId, {}, backendSrv, datasourceSrv); + var dbConnectorOptions = { datasourceId: datasourceId }; + this.dbConnector = new SQLConnector(dbConnectorOptions, backendSrv, datasourceSrv); this.getHistoryDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getHistory, 'getHistory', this.dbConnector); this.getTrendsDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getTrends, 'getTrends', this.dbConnector); } @@ -442,6 +446,79 @@ System.register(['lodash', '../utils', './connectors/zabbix_api/zabbixAPIConnect return _this5.zabbixAPI.getTriggers(query.groupids, query.hostids, query.applicationids, options); }); } + }, { + key: 'getHistoryTS', + value: function getHistoryTS(items, timeRange, options) { + var _this6 = this; + + var _timeRange = _slicedToArray(timeRange, 2), + timeFrom = _timeRange[0], + timeTo = _timeRange[1]; + + if (this.enableDirectDBConnection) { + return this.getHistoryDB(items, timeFrom, timeTo, options).then(function (history) { + return _this6.dbConnector.handleGrafanaTSResponse(history, items); + }); + } else { + return this.zabbixAPI.getHistory(items, timeFrom, timeTo).then(function (history) { + return responseHandler.handleHistory(history, items); + }); + } + } + }, { + key: 'getTrends', + value: function getTrends(items, timeRange, options) { + var _this7 = this; + + var _timeRange2 = _slicedToArray(timeRange, 2), + timeFrom = _timeRange2[0], + timeTo = _timeRange2[1]; + + if (this.enableDirectDBConnection) { + return this.getTrendsDB(items, timeFrom, timeTo, options).then(function (history) { + return _this7.dbConnector.handleGrafanaTSResponse(history, items); + }); + } else { + var valueType = options.consolidateBy || options.valueType; + return this.zabbixAPI.getTrend(items, timeFrom, timeTo).then(function (history) { + return responseHandler.handleTrends(history, items, valueType); + }).then(responseHandler.sortTimeseries); // Sort trend data, issue #202 + } + } + }, { + key: 'getHistoryText', + value: function getHistoryText(items, timeRange, target) { + var _timeRange3 = _slicedToArray(timeRange, 2), + timeFrom = _timeRange3[0], + timeTo = _timeRange3[1]; + + if (items.length) { + return this.zabbixAPI.getHistory(items, timeFrom, timeTo).then(function (history) { + if (target.resultFormat === 'table') { + return responseHandler.handleHistoryAsTable(history, items, target); + } else { + return responseHandler.handleText(history, items, target); + } + }); + } else { + return Promise.resolve([]); + } + } + }, { + key: 'getSLA', + value: function getSLA(itservices, timeRange, target, options) { + var itServices = itservices; + if (options.isOldVersion) { + itServices = _.filter(itServices, { 'serviceid': target.itservice.serviceid }); + } + var itServiceIds = _.map(itServices, 'serviceid'); + return this.zabbixAPI.getSLA(itServiceIds, timeRange).then(function (slaResponse) { + return _.map(itServiceIds, function (serviceid) { + var itservice = _.find(itServices, { 'serviceid': serviceid }); + return responseHandler.handleSLAResponse(itservice, target.slaProperty, slaResponse); + }); + }); + } }]); return Zabbix; diff --git a/dist/datasource-zabbix/zabbix/zabbix.js.map b/dist/datasource-zabbix/zabbix/zabbix.js.map index 51ac765..c785a7f 100644 --- a/dist/datasource-zabbix/zabbix/zabbix.js.map +++ b/dist/datasource-zabbix/zabbix/zabbix.js.map @@ -1 +1 @@ -{"version":3,"sources":["../../../src/datasource-zabbix/zabbix/zabbix.js"],"names":["findByName","list","name","finded","_","find","filterByName","filter","filterByRegex","regex","filterPattern","utils","buildRegex","zbx_obj","test","findByFilter","isRegex","filterByQuery","getHostIds","items","hostIds","map","item","hosts","uniq","flatten","ZabbixAPIConnector","ZabbixDBConnector","CachingProxy","REQUESTS_TO_PROXYFY","REQUESTS_TO_CACHE","REQUESTS_TO_BIND","Zabbix","url","options","backendSrv","datasourceSrv","username","password","basicAuth","withCredentials","cacheTTL","enableDirectDBConnection","sqlDatasourceId","cacheOptions","enabled","ttl","cachingProxy","zabbixAPI","dbConnector","getHistoryDB","proxyfyWithCache","getHistory","getTrendsDB","getTrends","proxyfyRequests","cacheRequests","bindRequests","request","proxyfy","cacheRequest","bind","target","parts","filters","p","getItems","Promise","all","getHosts","getApps","then","results","apps","appFilterEmpty","getGroups","groupFilter","getAllGroups","groups","groupids","hostFilter","getAllHosts","hostids","appFilter","undefined","itemtype","appids","showDisabledItems","expandUserMacro","getMacros","forEach","containsMacro","replaceMacro","macros","itemFilter","getAllItems","itServiceFilter","getITService","itServices","promises","filteredGroups","filteredHosts","filteredApps","query","applicationids","getTriggers"],"mappings":"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","file":"zabbix.js","sourcesContent":["import _ from 'lodash';\nimport * as utils from '../utils';\nimport { ZabbixAPIConnector } from './connectors/zabbix_api/zabbixAPIConnector';\nimport { ZabbixDBConnector } from './connectors/sql/zabbixDBConnector';\nimport { CachingProxy } from './proxy/cachingProxy';\n\nconst REQUESTS_TO_PROXYFY = [\n 'getHistory', 'getTrend', 'getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs',\n 'getEvents', 'getAlerts', 'getHostAlerts', 'getAcknowledges', 'getITService', 'getSLA', 'getVersion'\n];\n\nconst REQUESTS_TO_CACHE = [\n 'getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs', 'getITService'\n];\n\nconst REQUESTS_TO_BIND = [\n 'getHistory', 'getTrend', 'getMacros', 'getItemsByIDs', 'getEvents', 'getAlerts', 'getHostAlerts',\n 'getAcknowledges', 'getITService', 'getSLA', 'getVersion', 'login'\n];\n\nexport class Zabbix {\n\n /** @ngInject */\n constructor(url, options, backendSrv, datasourceSrv) {\n let {\n username,\n password,\n basicAuth,\n withCredentials,\n cacheTTL,\n enableDirectDBConnection,\n sqlDatasourceId\n } = options;\n\n // Initialize caching proxy for requests\n let cacheOptions = {\n enabled: true,\n ttl: cacheTTL\n };\n this.cachingProxy = new CachingProxy(cacheOptions);\n\n this.zabbixAPI = new ZabbixAPIConnector(url, username, password, basicAuth, withCredentials, backendSrv);\n\n if (enableDirectDBConnection) {\n this.dbConnector = new ZabbixDBConnector(sqlDatasourceId, {}, backendSrv, datasourceSrv);\n this.getHistoryDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getHistory, 'getHistory', this.dbConnector);\n this.getTrendsDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getTrends, 'getTrends', this.dbConnector);\n }\n\n this.proxyfyRequests();\n this.cacheRequests();\n this.bindRequests();\n }\n\n proxyfyRequests() {\n for (let request of REQUESTS_TO_PROXYFY) {\n this.zabbixAPI[request] = this.cachingProxy.proxyfy(this.zabbixAPI[request], request, this.zabbixAPI);\n }\n }\n\n cacheRequests() {\n for (let request of REQUESTS_TO_CACHE) {\n this.zabbixAPI[request] = this.cachingProxy.cacheRequest(this.zabbixAPI[request], request, this.zabbixAPI);\n }\n }\n\n bindRequests() {\n for (let request of REQUESTS_TO_BIND) {\n this[request] = this.zabbixAPI[request].bind(this.zabbixAPI);\n }\n }\n\n getItemsFromTarget(target, options) {\n let parts = ['group', 'host', 'application', 'item'];\n let filters = _.map(parts, p => target[p].filter);\n return this.getItems(...filters, options);\n }\n\n getHostsFromTarget(target) {\n let parts = ['group', 'host', 'application'];\n let filters = _.map(parts, p => target[p].filter);\n return Promise.all([\n this.getHosts(...filters),\n this.getApps(...filters),\n ]).then((results) => {\n let [hosts, apps] = results;\n if (apps.appFilterEmpty) {\n apps = [];\n }\n return [hosts, apps];\n });\n }\n\n getAllGroups() {\n return this.zabbixAPI.getGroups();\n }\n\n getGroups(groupFilter) {\n return this.getAllGroups()\n .then(groups => findByFilter(groups, groupFilter));\n }\n\n /**\n * Get list of host belonging to given groups.\n */\n getAllHosts(groupFilter) {\n return this.getGroups(groupFilter)\n .then(groups => {\n let groupids = _.map(groups, 'groupid');\n return this.zabbixAPI.getHosts(groupids);\n });\n }\n\n getHosts(groupFilter, hostFilter) {\n return this.getAllHosts(groupFilter)\n .then(hosts => findByFilter(hosts, hostFilter));\n }\n\n /**\n * Get list of applications belonging to given groups and hosts.\n */\n getAllApps(groupFilter, hostFilter) {\n return this.getHosts(groupFilter, hostFilter)\n .then(hosts => {\n let hostids = _.map(hosts, 'hostid');\n return this.zabbixAPI.getApps(hostids);\n });\n }\n\n getApps(groupFilter, hostFilter, appFilter) {\n return this.getHosts(groupFilter, hostFilter)\n .then(hosts => {\n let hostids = _.map(hosts, 'hostid');\n if (appFilter) {\n return this.zabbixAPI.getApps(hostids)\n .then(apps => filterByQuery(apps, appFilter));\n } else {\n return {\n appFilterEmpty: true,\n hostids: hostids\n };\n }\n });\n }\n\n getAllItems(groupFilter, hostFilter, appFilter, options = {}) {\n return this.getApps(groupFilter, hostFilter, appFilter)\n .then(apps => {\n if (apps.appFilterEmpty) {\n return this.zabbixAPI.getItems(apps.hostids, undefined, options.itemtype);\n } else {\n let appids = _.map(apps, 'applicationid');\n return this.zabbixAPI.getItems(undefined, appids, options.itemtype);\n }\n })\n .then(items => {\n if (!options.showDisabledItems) {\n items = _.filter(items, {'status': '0'});\n }\n\n return items;\n })\n .then(this.expandUserMacro.bind(this));\n }\n\n expandUserMacro(items) {\n let hostids = getHostIds(items);\n return this.getMacros(hostids)\n .then(macros => {\n _.forEach(items, item => {\n if (utils.containsMacro(item.name)) {\n item.name = utils.replaceMacro(item, macros);\n }\n });\n return items;\n });\n }\n\n getItems(groupFilter, hostFilter, appFilter, itemFilter, options = {}) {\n return this.getAllItems(groupFilter, hostFilter, appFilter, options)\n .then(items => filterByQuery(items, itemFilter));\n }\n\n getITServices(itServiceFilter) {\n return this.zabbixAPI.getITService()\n .then(itServices => findByFilter(itServices, itServiceFilter));\n }\n\n /**\n * Build query - convert target filters to array of Zabbix items\n */\n getTriggers(groupFilter, hostFilter, appFilter, options) {\n let promises = [\n this.getGroups(groupFilter),\n this.getHosts(groupFilter, hostFilter),\n this.getApps(groupFilter, hostFilter, appFilter)\n ];\n\n return Promise.all(promises)\n .then(results => {\n let filteredGroups = results[0];\n let filteredHosts = results[1];\n let filteredApps = results[2];\n let query = {};\n\n if (appFilter) {\n query.applicationids = _.flatten(_.map(filteredApps, 'applicationid'));\n }\n if (hostFilter) {\n query.hostids = _.map(filteredHosts, 'hostid');\n }\n if (groupFilter) {\n query.groupids = _.map(filteredGroups, 'groupid');\n }\n\n return query;\n }).then(query => {\n return this.zabbixAPI.getTriggers(query.groupids, query.hostids, query.applicationids, options);\n });\n }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Find group, host, app or item by given name.\n * @param list list of groups, apps or other\n * @param name visible name\n * @return array with finded element or empty array\n */\nfunction findByName(list, name) {\n var finded = _.find(list, {'name': name});\n if (finded) {\n return [finded];\n } else {\n return [];\n }\n}\n\n/**\n * Different hosts can contains applications and items with same name.\n * For this reason use _.filter, which return all elements instead _.find,\n * which return only first finded.\n * @param {[type]} list list of elements\n * @param {[type]} name app name\n * @return {[type]} array with finded element or empty array\n */\nfunction filterByName(list, name) {\n var finded = _.filter(list, {'name': name});\n if (finded) {\n return finded;\n } else {\n return [];\n }\n}\n\nfunction filterByRegex(list, regex) {\n var filterPattern = utils.buildRegex(regex);\n return _.filter(list, function (zbx_obj) {\n return filterPattern.test(zbx_obj.name);\n });\n}\n\nfunction findByFilter(list, filter) {\n if (utils.isRegex(filter)) {\n return filterByRegex(list, filter);\n } else {\n return findByName(list, filter);\n }\n}\n\nfunction filterByQuery(list, filter) {\n if (utils.isRegex(filter)) {\n return filterByRegex(list, filter);\n } else {\n return filterByName(list, filter);\n }\n}\n\nfunction getHostIds(items) {\n let hostIds = _.map(items, item => {\n return _.map(item.hosts, 'hostid');\n });\n return _.uniq(_.flatten(hostIds));\n}\n"]} \ No newline at end of file +{"version":3,"sources":["../../../src/datasource-zabbix/zabbix/zabbix.js"],"names":["findByName","list","name","finded","_","find","filterByName","filter","filterByRegex","regex","filterPattern","utils","buildRegex","zbx_obj","test","findByFilter","isRegex","filterByQuery","getHostIds","items","hostIds","map","item","hosts","uniq","flatten","responseHandler","ZabbixAPIConnector","SQLConnector","CachingProxy","REQUESTS_TO_PROXYFY","REQUESTS_TO_CACHE","REQUESTS_TO_BIND","Zabbix","options","backendSrv","datasourceSrv","url","username","password","basicAuth","withCredentials","cacheTTL","enableDirectDBConnection","datasourceId","cacheOptions","enabled","ttl","cachingProxy","zabbixAPI","dbConnectorOptions","dbConnector","getHistoryDB","proxyfyWithCache","getHistory","getTrendsDB","getTrends","proxyfyRequests","cacheRequests","bindRequests","request","proxyfy","cacheRequest","bind","target","parts","filters","p","getItems","Promise","all","getHosts","getApps","then","results","apps","appFilterEmpty","getGroups","groupFilter","getAllGroups","groups","groupids","hostFilter","getAllHosts","hostids","appFilter","undefined","itemtype","appids","showDisabledItems","expandUserMacro","getMacros","forEach","containsMacro","replaceMacro","macros","itemFilter","getAllItems","itServiceFilter","getITService","itServices","promises","filteredGroups","filteredHosts","filteredApps","query","applicationids","getTriggers","timeRange","timeFrom","timeTo","handleGrafanaTSResponse","history","handleHistory","valueType","consolidateBy","getTrend","handleTrends","sortTimeseries","length","resultFormat","handleHistoryAsTable","handleText","resolve","itservices","isOldVersion","itservice","serviceid","itServiceIds","getSLA","handleSLAResponse","slaProperty","slaResponse"],"mappings":"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","file":"zabbix.js","sourcesContent":["import _ from 'lodash';\nimport * as utils from '../utils';\nimport responseHandler from '../responseHandler';\nimport { ZabbixAPIConnector } from './connectors/zabbix_api/zabbixAPIConnector';\nimport { SQLConnector } from './connectors/sql/sqlConnector';\nimport { CachingProxy } from './proxy/cachingProxy';\n\nconst REQUESTS_TO_PROXYFY = [\n 'getHistory', 'getTrend', 'getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs',\n 'getEvents', 'getAlerts', 'getHostAlerts', 'getAcknowledges', 'getITService', 'getSLA', 'getVersion'\n];\n\nconst REQUESTS_TO_CACHE = [\n 'getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs', 'getITService'\n];\n\nconst REQUESTS_TO_BIND = [\n 'getHistory', 'getTrend', 'getMacros', 'getItemsByIDs', 'getEvents', 'getAlerts', 'getHostAlerts',\n 'getAcknowledges', 'getITService', 'getVersion', 'login'\n];\n\nexport class Zabbix {\n constructor(options, backendSrv, datasourceSrv) {\n let {\n url,\n username,\n password,\n basicAuth,\n withCredentials,\n cacheTTL,\n enableDirectDBConnection,\n datasourceId\n } = options;\n\n this.enableDirectDBConnection = enableDirectDBConnection;\n\n // Initialize caching proxy for requests\n let cacheOptions = {\n enabled: true,\n ttl: cacheTTL\n };\n this.cachingProxy = new CachingProxy(cacheOptions);\n\n this.zabbixAPI = new ZabbixAPIConnector(url, username, password, basicAuth, withCredentials, backendSrv);\n\n if (enableDirectDBConnection) {\n let dbConnectorOptions = { datasourceId };\n this.dbConnector = new SQLConnector(dbConnectorOptions, backendSrv, datasourceSrv);\n this.getHistoryDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getHistory, 'getHistory', this.dbConnector);\n this.getTrendsDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getTrends, 'getTrends', this.dbConnector);\n }\n\n this.proxyfyRequests();\n this.cacheRequests();\n this.bindRequests();\n }\n\n proxyfyRequests() {\n for (let request of REQUESTS_TO_PROXYFY) {\n this.zabbixAPI[request] = this.cachingProxy.proxyfy(this.zabbixAPI[request], request, this.zabbixAPI);\n }\n }\n\n cacheRequests() {\n for (let request of REQUESTS_TO_CACHE) {\n this.zabbixAPI[request] = this.cachingProxy.cacheRequest(this.zabbixAPI[request], request, this.zabbixAPI);\n }\n }\n\n bindRequests() {\n for (let request of REQUESTS_TO_BIND) {\n this[request] = this.zabbixAPI[request].bind(this.zabbixAPI);\n }\n }\n\n getItemsFromTarget(target, options) {\n let parts = ['group', 'host', 'application', 'item'];\n let filters = _.map(parts, p => target[p].filter);\n return this.getItems(...filters, options);\n }\n\n getHostsFromTarget(target) {\n let parts = ['group', 'host', 'application'];\n let filters = _.map(parts, p => target[p].filter);\n return Promise.all([\n this.getHosts(...filters),\n this.getApps(...filters),\n ]).then((results) => {\n let [hosts, apps] = results;\n if (apps.appFilterEmpty) {\n apps = [];\n }\n return [hosts, apps];\n });\n }\n\n getAllGroups() {\n return this.zabbixAPI.getGroups();\n }\n\n getGroups(groupFilter) {\n return this.getAllGroups()\n .then(groups => findByFilter(groups, groupFilter));\n }\n\n /**\n * Get list of host belonging to given groups.\n */\n getAllHosts(groupFilter) {\n return this.getGroups(groupFilter)\n .then(groups => {\n let groupids = _.map(groups, 'groupid');\n return this.zabbixAPI.getHosts(groupids);\n });\n }\n\n getHosts(groupFilter, hostFilter) {\n return this.getAllHosts(groupFilter)\n .then(hosts => findByFilter(hosts, hostFilter));\n }\n\n /**\n * Get list of applications belonging to given groups and hosts.\n */\n getAllApps(groupFilter, hostFilter) {\n return this.getHosts(groupFilter, hostFilter)\n .then(hosts => {\n let hostids = _.map(hosts, 'hostid');\n return this.zabbixAPI.getApps(hostids);\n });\n }\n\n getApps(groupFilter, hostFilter, appFilter) {\n return this.getHosts(groupFilter, hostFilter)\n .then(hosts => {\n let hostids = _.map(hosts, 'hostid');\n if (appFilter) {\n return this.zabbixAPI.getApps(hostids)\n .then(apps => filterByQuery(apps, appFilter));\n } else {\n return {\n appFilterEmpty: true,\n hostids: hostids\n };\n }\n });\n }\n\n getAllItems(groupFilter, hostFilter, appFilter, options = {}) {\n return this.getApps(groupFilter, hostFilter, appFilter)\n .then(apps => {\n if (apps.appFilterEmpty) {\n return this.zabbixAPI.getItems(apps.hostids, undefined, options.itemtype);\n } else {\n let appids = _.map(apps, 'applicationid');\n return this.zabbixAPI.getItems(undefined, appids, options.itemtype);\n }\n })\n .then(items => {\n if (!options.showDisabledItems) {\n items = _.filter(items, {'status': '0'});\n }\n\n return items;\n })\n .then(this.expandUserMacro.bind(this));\n }\n\n expandUserMacro(items) {\n let hostids = getHostIds(items);\n return this.getMacros(hostids)\n .then(macros => {\n _.forEach(items, item => {\n if (utils.containsMacro(item.name)) {\n item.name = utils.replaceMacro(item, macros);\n }\n });\n return items;\n });\n }\n\n getItems(groupFilter, hostFilter, appFilter, itemFilter, options = {}) {\n return this.getAllItems(groupFilter, hostFilter, appFilter, options)\n .then(items => filterByQuery(items, itemFilter));\n }\n\n getITServices(itServiceFilter) {\n return this.zabbixAPI.getITService()\n .then(itServices => findByFilter(itServices, itServiceFilter));\n }\n\n /**\n * Build query - convert target filters to array of Zabbix items\n */\n getTriggers(groupFilter, hostFilter, appFilter, options) {\n let promises = [\n this.getGroups(groupFilter),\n this.getHosts(groupFilter, hostFilter),\n this.getApps(groupFilter, hostFilter, appFilter)\n ];\n\n return Promise.all(promises)\n .then(results => {\n let filteredGroups = results[0];\n let filteredHosts = results[1];\n let filteredApps = results[2];\n let query = {};\n\n if (appFilter) {\n query.applicationids = _.flatten(_.map(filteredApps, 'applicationid'));\n }\n if (hostFilter) {\n query.hostids = _.map(filteredHosts, 'hostid');\n }\n if (groupFilter) {\n query.groupids = _.map(filteredGroups, 'groupid');\n }\n\n return query;\n }).then(query => {\n return this.zabbixAPI.getTriggers(query.groupids, query.hostids, query.applicationids, options);\n });\n }\n\n getHistoryTS(items, timeRange, options) {\n let [timeFrom, timeTo] = timeRange;\n if (this.enableDirectDBConnection) {\n return this.getHistoryDB(items, timeFrom, timeTo, options)\n .then(history => this.dbConnector.handleGrafanaTSResponse(history, items));\n } else {\n return this.zabbixAPI.getHistory(items, timeFrom, timeTo)\n .then(history => responseHandler.handleHistory(history, items));\n }\n }\n\n getTrends(items, timeRange, options) {\n let [timeFrom, timeTo] = timeRange;\n if (this.enableDirectDBConnection) {\n return this.getTrendsDB(items, timeFrom, timeTo, options)\n .then(history => this.dbConnector.handleGrafanaTSResponse(history, items));\n } else {\n let valueType = options.consolidateBy || options.valueType;\n return this.zabbixAPI.getTrend(items, timeFrom, timeTo)\n .then(history => responseHandler.handleTrends(history, items, valueType))\n .then(responseHandler.sortTimeseries); // Sort trend data, issue #202\n }\n }\n\n getHistoryText(items, timeRange, target) {\n let [timeFrom, timeTo] = timeRange;\n if (items.length) {\n return this.zabbixAPI.getHistory(items, timeFrom, timeTo)\n .then(history => {\n if (target.resultFormat === 'table') {\n return responseHandler.handleHistoryAsTable(history, items, target);\n } else {\n return responseHandler.handleText(history, items, target);\n }\n });\n } else {\n return Promise.resolve([]);\n }\n }\n\n getSLA(itservices, timeRange, target, options) {\n let itServices = itservices;\n if (options.isOldVersion) {\n itServices = _.filter(itServices, {'serviceid': target.itservice.serviceid});\n }\n let itServiceIds = _.map(itServices, 'serviceid');\n return this.zabbixAPI.getSLA(itServiceIds, timeRange)\n .then(slaResponse => {\n return _.map(itServiceIds, serviceid => {\n let itservice = _.find(itServices, {'serviceid': serviceid});\n return responseHandler.handleSLAResponse(itservice, target.slaProperty, slaResponse);\n });\n });\n }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Find group, host, app or item by given name.\n * @param list list of groups, apps or other\n * @param name visible name\n * @return array with finded element or empty array\n */\nfunction findByName(list, name) {\n var finded = _.find(list, {'name': name});\n if (finded) {\n return [finded];\n } else {\n return [];\n }\n}\n\n/**\n * Different hosts can contains applications and items with same name.\n * For this reason use _.filter, which return all elements instead _.find,\n * which return only first finded.\n * @param {[type]} list list of elements\n * @param {[type]} name app name\n * @return {[type]} array with finded element or empty array\n */\nfunction filterByName(list, name) {\n var finded = _.filter(list, {'name': name});\n if (finded) {\n return finded;\n } else {\n return [];\n }\n}\n\nfunction filterByRegex(list, regex) {\n var filterPattern = utils.buildRegex(regex);\n return _.filter(list, function (zbx_obj) {\n return filterPattern.test(zbx_obj.name);\n });\n}\n\nfunction findByFilter(list, filter) {\n if (utils.isRegex(filter)) {\n return filterByRegex(list, filter);\n } else {\n return findByName(list, filter);\n }\n}\n\nfunction filterByQuery(list, filter) {\n if (utils.isRegex(filter)) {\n return filterByRegex(list, filter);\n } else {\n return filterByName(list, filter);\n }\n}\n\nfunction getHostIds(items) {\n let hostIds = _.map(items, item => {\n return _.map(item.hosts, 'hostid');\n });\n return _.uniq(_.flatten(hostIds));\n}\n"]} \ No newline at end of file diff --git a/src/datasource-zabbix/datasource.js b/src/datasource-zabbix/datasource.js index 99e4a7e..4a91e31 100644 --- a/src/datasource-zabbix/datasource.js +++ b/src/datasource-zabbix/datasource.js @@ -54,7 +54,7 @@ class ZabbixAPIDatasource { // Direct DB Connection options let dbConnectionOptions = jsonData.dbConnection || {}; this.enableDirectDBConnection = dbConnectionOptions.enable; - this.sqlDatasourceId = dbConnectionOptions.datasourceId; + this.datasourceId = dbConnectionOptions.datasourceId; let zabbixOptions = { url: this.url, @@ -64,7 +64,7 @@ class ZabbixAPIDatasource { withCredentials: this.withCredentials, cacheTTL: this.cacheTTL, enableDirectDBConnection: this.enableDirectDBConnection, - sqlDatasourceId: this.sqlDatasourceId + datasourceId: this.datasourceId }; this.zabbix = new Zabbix(zabbixOptions, backendSrv, datasourceSrv); @@ -350,7 +350,7 @@ class ZabbixAPIDatasource { }) .then(() => { if (this.enableDirectDBConnection) { - return this.zabbix.dbConnector.testSQLDataSource(); + return this.zabbix.dbConnector.testDataSource(); } else { return Promise.resolve(); } diff --git a/src/datasource-zabbix/zabbix/connectors/dbConnector.js b/src/datasource-zabbix/zabbix/connectors/dbConnector.js new file mode 100644 index 0000000..1974d35 --- /dev/null +++ b/src/datasource-zabbix/zabbix/connectors/dbConnector.js @@ -0,0 +1,38 @@ +import _ from 'lodash'; + +const NOT_IMPLEMENTED = 'Method should be implemented in subclass of DBConnector'; + +export default class DBConnector { + constructor(options, backendSrv, datasourceSrv) { + this.backendSrv = backendSrv; + this.datasourceSrv = datasourceSrv; + this.datasourceId = options.datasourceId; + this.datasourceName = options.datasourceName; + this.datasourceType = null; + } + + loadDBDataSource() { + let ds = _.find(this.datasourceSrv.getAll(), {'id': this.datasourceId}); + if (ds) { + return this.datasourceSrv.loadDatasource(ds.name) + .then(ds => { + this.datasourceType = ds.meta.id; + return ds; + }); + } else { + return Promise.reject(`SQL Data Source with ID ${this.datasourceId} not found`); + } + } + + testDataSource() { + throw NOT_IMPLEMENTED; + } + + getHistory() { + throw NOT_IMPLEMENTED; + } + + getTrends() { + throw NOT_IMPLEMENTED; + } +} diff --git a/src/datasource-zabbix/zabbix/connectors/sql/mysql.js b/src/datasource-zabbix/zabbix/connectors/sql/mysql.js new file mode 100644 index 0000000..31f0efa --- /dev/null +++ b/src/datasource-zabbix/zabbix/connectors/sql/mysql.js @@ -0,0 +1,43 @@ +/** + * MySQL queries + */ + +function historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) { + let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`; + let query = ` + SELECT CAST(itemid AS CHAR) AS metric, ${time_expression} AS time_sec, ${aggFunction}(value) AS value + FROM ${table} + WHERE itemid IN (${itemids}) + AND clock > ${timeFrom} AND clock < ${timeTill} + GROUP BY ${time_expression}, metric + ORDER BY time_sec ASC + `; + return query; +} + +function trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) { + let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`; + let query = ` + SELECT CAST(itemid AS CHAR) AS metric, ${time_expression} AS time_sec, ${aggFunction}(${valueColumn}) AS value + FROM ${table} + WHERE itemid IN (${itemids}) + AND clock > ${timeFrom} AND clock < ${timeTill} + GROUP BY ${time_expression}, metric + ORDER BY time_sec ASC + `; + return query; +} + +const TEST_QUERY = `SELECT CAST(itemid AS CHAR) AS metric, clock AS time_sec, value_avg AS value FROM trends_uint LIMIT 1`; + +function testQuery() { + return TEST_QUERY; +} + +const mysql = { + historyQuery, + trendsQuery, + testQuery +}; + +export default mysql; diff --git a/src/datasource-zabbix/zabbix/connectors/sql/postgres.js b/src/datasource-zabbix/zabbix/connectors/sql/postgres.js new file mode 100644 index 0000000..f1689b4 --- /dev/null +++ b/src/datasource-zabbix/zabbix/connectors/sql/postgres.js @@ -0,0 +1,48 @@ +/** + * Postgres queries + */ + +const ITEMID_FORMAT = 'FM99999999999999999999'; + +function historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) { + let time_expression = `clock / ${intervalSec} * ${intervalSec}`; + let query = ` + SELECT to_char(itemid, '${ITEMID_FORMAT}') AS metric, ${time_expression} AS time, ${aggFunction}(value) AS value + FROM ${table} + WHERE itemid IN (${itemids}) + AND clock > ${timeFrom} AND clock < ${timeTill} + GROUP BY 1, 2 + ORDER BY time ASC + `; + return query; +} + +function trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) { + let time_expression = `clock / ${intervalSec} * ${intervalSec}`; + let query = ` + SELECT to_char(itemid, '${ITEMID_FORMAT}') AS metric, ${time_expression} AS time, ${aggFunction}(${valueColumn}) AS value + FROM ${table} + WHERE itemid IN (${itemids}) + AND clock > ${timeFrom} AND clock < ${timeTill} + GROUP BY 1, 2 + ORDER BY time ASC + `; + return query; +} + +const TEST_QUERY = ` + SELECT to_char(itemid, '${ITEMID_FORMAT}') AS metric, clock AS time, value_avg AS value + FROM trends_uint LIMIT 1 +`; + +function testQuery() { + return TEST_QUERY; +} + +const postgres = { + historyQuery, + trendsQuery, + testQuery +}; + +export default postgres; diff --git a/src/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js b/src/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js new file mode 100644 index 0000000..75b5678 --- /dev/null +++ b/src/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js @@ -0,0 +1,173 @@ +import _ from 'lodash'; +import mysql from './mysql'; +import postgres from './postgres'; +import DBConnector from '../dbConnector'; + +const supportedDatabases = { + mysql: 'mysql', + postgres: 'postgres' +}; + +const DEFAULT_QUERY_LIMIT = 10000; +const HISTORY_TO_TABLE_MAP = { + '0': 'history', + '1': 'history_str', + '2': 'history_log', + '3': 'history_uint', + '4': 'history_text' +}; + +const TREND_TO_TABLE_MAP = { + '0': 'trends', + '3': 'trends_uint' +}; + +const consolidateByFunc = { + 'avg': 'AVG', + 'min': 'MIN', + 'max': 'MAX', + 'sum': 'SUM', + 'count': 'COUNT' +}; + +const consolidateByTrendColumns = { + 'avg': 'value_avg', + 'min': 'value_min', + 'max': 'value_max' +}; + +export class SQLConnector extends DBConnector { + constructor(options, backendSrv, datasourceSrv) { + super(options, backendSrv, datasourceSrv); + + this.limit = options.limit || DEFAULT_QUERY_LIMIT; + this.sqlDialect = null; + + super.loadDBDataSource() + .then(() => this.loadSQLDialect()); + } + + loadSQLDialect() { + if (this.datasourceType === supportedDatabases.postgres) { + this.sqlDialect = postgres; + } else { + this.sqlDialect = mysql; + } + } + + /** + * Try to invoke test query for one of Zabbix database tables. + */ + testDataSource() { + let testQuery = this.sqlDialect.testQuery(); + return this.invokeSQLQuery(testQuery); + } + + getHistory(items, timeFrom, timeTill, options) { + let {intervalMs, consolidateBy} = options; + let intervalSec = Math.ceil(intervalMs / 1000); + + consolidateBy = consolidateBy || 'avg'; + let aggFunction = consolidateByFunc[consolidateBy]; + + // Group items by value type and perform request for each value type + let grouped_items = _.groupBy(items, 'value_type'); + let promises = _.map(grouped_items, (items, value_type) => { + let itemids = _.map(items, 'itemid').join(', '); + let table = HISTORY_TO_TABLE_MAP[value_type]; + let query = this.sqlDialect.historyQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction); + + query = compactSQLQuery(query); + return this.invokeSQLQuery(query); + }); + + return Promise.all(promises).then(results => { + return _.flatten(results); + }); + } + + getTrends(items, timeFrom, timeTill, options) { + let { intervalMs, consolidateBy } = options; + let intervalSec = Math.ceil(intervalMs / 1000); + + consolidateBy = consolidateBy || 'avg'; + let aggFunction = consolidateByFunc[consolidateBy]; + + // Group items by value type and perform request for each value type + let grouped_items = _.groupBy(items, 'value_type'); + let promises = _.map(grouped_items, (items, value_type) => { + let itemids = _.map(items, 'itemid').join(', '); + let table = TREND_TO_TABLE_MAP[value_type]; + let valueColumn = _.includes(['avg', 'min', 'max'], consolidateBy) ? consolidateBy : 'avg'; + valueColumn = consolidateByTrendColumns[valueColumn]; + let query = this.sqlDialect.trendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn); + + query = compactSQLQuery(query); + return this.invokeSQLQuery(query); + }); + + return Promise.all(promises).then(results => { + return _.flatten(results); + }); + } + + handleGrafanaTSResponse(history, items, addHostName = true) { + return convertGrafanaTSResponse(history, items, addHostName); + } + + invokeSQLQuery(query) { + let queryDef = { + refId: 'A', + format: 'time_series', + datasourceId: this.datasourceId, + rawSql: query, + maxDataPoints: this.limit + }; + + return this.backendSrv.datasourceRequest({ + url: '/api/tsdb/query', + method: 'POST', + data: { + queries: [queryDef], + } + }) + .then(response => { + let results = response.data.results; + if (results['A']) { + return results['A'].series; + } else { + return null; + } + }); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +function convertGrafanaTSResponse(time_series, items, addHostName) { + //uniqBy is needed to deduplicate + var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid'); + let grafanaSeries = _.map(time_series, series => { + let itemid = series.name; + var item = _.find(items, {'itemid': itemid}); + var alias = item.name; + //only when actual multi hosts selected + if (_.keys(hosts).length > 1 && addHostName) { + var host = _.find(hosts, {'hostid': item.hostid}); + alias = host.name + ": " + alias; + } + // CachingProxy deduplicates requests and returns one time series for equal queries. + // Clone is needed to prevent changing of series object shared between all targets. + let datapoints = _.cloneDeep(series.points); + return { + target: alias, + datapoints: datapoints + }; + }); + + return _.sortBy(grafanaSeries, 'target'); +} + +function compactSQLQuery(query) { + return query.replace(/\s+/g, ' '); +} diff --git a/src/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js b/src/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js deleted file mode 100644 index ed46308..0000000 --- a/src/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js +++ /dev/null @@ -1,266 +0,0 @@ -import _ from 'lodash'; - -const DEFAULT_QUERY_LIMIT = 10000; -const HISTORY_TO_TABLE_MAP = { - '0': 'history', - '1': 'history_str', - '2': 'history_log', - '3': 'history_uint', - '4': 'history_text' -}; - -const TREND_TO_TABLE_MAP = { - '0': 'trends', - '3': 'trends_uint' -}; - -const consolidateByFunc = { - 'avg': 'AVG', - 'min': 'MIN', - 'max': 'MAX', - 'sum': 'SUM', - 'count': 'COUNT' -}; - -const consolidateByTrendColumns = { - 'avg': 'value_avg', - 'min': 'value_min', - 'max': 'value_max' -}; - -export class ZabbixDBConnector { - - constructor(sqlDataSourceId, options, backendSrv, datasourceSrv) { - this.backendSrv = backendSrv; - this.datasourceSrv = datasourceSrv; - - let limit = options.limit; - this.sqlDataSourceId = sqlDataSourceId; - this.limit = limit || DEFAULT_QUERY_LIMIT; - - this.loadSQLDataSource(sqlDataSourceId); - } - - /** - * Try to load DS with given id to check it's exist. - * @param {*} datasourceId ID of SQL data source - */ - loadSQLDataSource(datasourceId) { - let ds = _.find(this.datasourceSrv.getAll(), {'id': datasourceId}); - if (ds) { - return this.datasourceSrv.loadDatasource(ds.name) - .then(ds => { - this.sqlDataSourceType = ds.meta.id; - return ds; - }); - } else { - return Promise.reject(`SQL Data Source with ID ${datasourceId} not found`); - } - } - - /** - * Try to invoke test query for one of Zabbix database tables. - */ - testSQLDataSource() { - let testQuery = TEST_MYSQL_QUERY; - if (this.sqlDataSourceType === 'postgres') { - testQuery = TEST_POSTGRES_QUERY; - } - return this.invokeSQLQuery(testQuery); - } - - getHistory(items, timeFrom, timeTill, options) { - let {intervalMs, consolidateBy} = options; - let intervalSec = Math.ceil(intervalMs / 1000); - - consolidateBy = consolidateBy || 'avg'; - let aggFunction = consolidateByFunc[consolidateBy]; - - // Group items by value type and perform request for each value type - let grouped_items = _.groupBy(items, 'value_type'); - let promises = _.map(grouped_items, (items, value_type) => { - let itemids = _.map(items, 'itemid').join(', '); - let table = HISTORY_TO_TABLE_MAP[value_type]; - - let dialect = this.sqlDataSourceType; - let query = buildSQLHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, dialect); - - query = compactSQLQuery(query); - return this.invokeSQLQuery(query); - }); - - return Promise.all(promises).then(results => { - return _.flatten(results); - }); - } - - getTrends(items, timeFrom, timeTill, options) { - let { intervalMs, consolidateBy } = options; - let intervalSec = Math.ceil(intervalMs / 1000); - - consolidateBy = consolidateBy || 'avg'; - let aggFunction = consolidateByFunc[consolidateBy]; - - // Group items by value type and perform request for each value type - let grouped_items = _.groupBy(items, 'value_type'); - let promises = _.map(grouped_items, (items, value_type) => { - let itemids = _.map(items, 'itemid').join(', '); - let table = TREND_TO_TABLE_MAP[value_type]; - let valueColumn = _.includes(['avg', 'min', 'max'], consolidateBy) ? consolidateBy : 'avg'; - valueColumn = consolidateByTrendColumns[valueColumn]; - - let dialect = this.sqlDataSourceType; - let query = buildSQLTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn, dialect); - - query = compactSQLQuery(query); - return this.invokeSQLQuery(query); - }); - - return Promise.all(promises).then(results => { - return _.flatten(results); - }); - } - - handleGrafanaTSResponse(history, items, addHostName = true) { - return convertGrafanaTSResponse(history, items, addHostName); - } - - invokeSQLQuery(query) { - let queryDef = { - refId: 'A', - format: 'time_series', - datasourceId: this.sqlDataSourceId, - rawSql: query, - maxDataPoints: this.limit - }; - - return this.backendSrv.datasourceRequest({ - url: '/api/tsdb/query', - method: 'POST', - data: { - queries: [queryDef], - } - }) - .then(response => { - let results = response.data.results; - if (results['A']) { - return results['A'].series; - } else { - return null; - } - }); - } -} - -/////////////////////////////////////////////////////////////////////////////// - -function convertGrafanaTSResponse(time_series, items, addHostName) { - var hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid'); //uniqBy is needed to deduplicate - let grafanaSeries = _.map(time_series, series => { - let itemid = series.name; - var item = _.find(items, {'itemid': itemid}); - var alias = item.name; - if (_.keys(hosts).length > 1 && addHostName) { //only when actual multi hosts selected - var host = _.find(hosts, {'hostid': item.hostid}); - alias = host.name + ": " + alias; - } - // CachingProxy deduplicates requests and returns one time series for equal queries. - // Clone is needed to prevent changing of series object shared between all targets. - let datapoints = _.cloneDeep(series.points); - return { - target: alias, - datapoints: datapoints - }; - }); - - return _.sortBy(grafanaSeries, 'target'); -} - -function compactSQLQuery(query) { - return query.replace(/\s+/g, ' '); -} - -function buildSQLHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, dialect = 'mysql') { - if (dialect === 'postgres') { - return buildPostgresHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction); - } else { - return buildMysqlHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction); - } -} - -function buildSQLTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn, dialect = 'mysql') { - if (dialect === 'postgres') { - return buildPostgresTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn); - } else { - return buildMysqlTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn); - } -} - -/////////// -// MySQL // -/////////// - -function buildMysqlHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) { - let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`; - let query = ` - SELECT CAST(itemid AS CHAR) AS metric, ${time_expression} AS time_sec, ${aggFunction}(value) AS value - FROM ${table} - WHERE itemid IN (${itemids}) - AND clock > ${timeFrom} AND clock < ${timeTill} - GROUP BY ${time_expression}, metric - ORDER BY time_sec ASC - `; - return query; -} - -function buildMysqlTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) { - let time_expression = `clock DIV ${intervalSec} * ${intervalSec}`; - let query = ` - SELECT CAST(itemid AS CHAR) AS metric, ${time_expression} AS time_sec, ${aggFunction}(${valueColumn}) AS value - FROM ${table} - WHERE itemid IN (${itemids}) - AND clock > ${timeFrom} AND clock < ${timeTill} - GROUP BY ${time_expression}, metric - ORDER BY time_sec ASC - `; - return query; -} - -const TEST_MYSQL_QUERY = `SELECT CAST(itemid AS CHAR) AS metric, clock AS time_sec, value_avg AS value FROM trends_uint LIMIT 1`; - -//////////////// -// PostgreSQL // -//////////////// - -const itemid_format = 'FM99999999999999999999'; - -function buildPostgresHistoryQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction) { - let time_expression = `clock / ${intervalSec} * ${intervalSec}`; - let query = ` - SELECT to_char(itemid, '${itemid_format}') AS metric, ${time_expression} AS time, ${aggFunction}(value) AS value - FROM ${table} - WHERE itemid IN (${itemids}) - AND clock > ${timeFrom} AND clock < ${timeTill} - GROUP BY 1, 2 - ORDER BY time ASC - `; - return query; -} - -function buildPostgresTrendsQuery(itemids, table, timeFrom, timeTill, intervalSec, aggFunction, valueColumn) { - let time_expression = `clock / ${intervalSec} * ${intervalSec}`; - let query = ` - SELECT to_char(itemid, '${itemid_format}') AS metric, ${time_expression} AS time, ${aggFunction}(${valueColumn}) AS value - FROM ${table} - WHERE itemid IN (${itemids}) - AND clock > ${timeFrom} AND clock < ${timeTill} - GROUP BY 1, 2 - ORDER BY time ASC - `; - return query; -} - -const TEST_POSTGRES_QUERY = ` - SELECT to_char(itemid, '${itemid_format}') AS metric, clock AS time, value_avg AS value - FROM trends_uint LIMIT 1 -`; diff --git a/src/datasource-zabbix/zabbix/connectors/zabbixConnector.js b/src/datasource-zabbix/zabbix/connectors/zabbixConnector.js deleted file mode 100644 index eb0ba14..0000000 --- a/src/datasource-zabbix/zabbix/connectors/zabbixConnector.js +++ /dev/null @@ -1,46 +0,0 @@ -/** - * Base class for all Zabbix connectors - */ - -export default class ZabbixConnector { - - constructor() {} - - testDataSource() {} - - getHistory() {} - - getTrends() {} - - getGroups() {} - - getHosts() {} - - getApps() {} - - getItems() {} - - getItemsByIDs() {} - - getMacros() {} - - getGlobalMacros() {} - - getLastValue() {} - - getTriggers() {} - - getEvents() {} - - getAlerts() {} - - getHostAlerts() {} - - getAcknowledges() {} - - getITService() {} - - getSLA() {} - - getVersion() {} -} diff --git a/src/datasource-zabbix/zabbix/zabbix.js b/src/datasource-zabbix/zabbix/zabbix.js index 2fd45bc..7fedd11 100644 --- a/src/datasource-zabbix/zabbix/zabbix.js +++ b/src/datasource-zabbix/zabbix/zabbix.js @@ -2,7 +2,7 @@ import _ from 'lodash'; import * as utils from '../utils'; import responseHandler from '../responseHandler'; import { ZabbixAPIConnector } from './connectors/zabbix_api/zabbixAPIConnector'; -import { ZabbixDBConnector } from './connectors/sql/zabbixDBConnector'; +import { SQLConnector } from './connectors/sql/sqlConnector'; import { CachingProxy } from './proxy/cachingProxy'; const REQUESTS_TO_PROXYFY = [ @@ -20,8 +20,6 @@ const REQUESTS_TO_BIND = [ ]; export class Zabbix { - - /** @ngInject */ constructor(options, backendSrv, datasourceSrv) { let { url, @@ -31,7 +29,7 @@ export class Zabbix { withCredentials, cacheTTL, enableDirectDBConnection, - sqlDatasourceId + datasourceId } = options; this.enableDirectDBConnection = enableDirectDBConnection; @@ -46,7 +44,8 @@ export class Zabbix { this.zabbixAPI = new ZabbixAPIConnector(url, username, password, basicAuth, withCredentials, backendSrv); if (enableDirectDBConnection) { - this.dbConnector = new ZabbixDBConnector(sqlDatasourceId, {}, backendSrv, datasourceSrv); + let dbConnectorOptions = { datasourceId }; + this.dbConnector = new SQLConnector(dbConnectorOptions, backendSrv, datasourceSrv); this.getHistoryDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getHistory, 'getHistory', this.dbConnector); this.getTrendsDB = this.cachingProxy.proxyfyWithCache(this.dbConnector.getTrends, 'getTrends', this.dbConnector); }