refactor: db connectors

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

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

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

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"]}

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

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"]}

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

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"]}

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

dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js

@@ -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

dist/datasource-zabbix/zabbix/connectors/zabbixConnector.js.map

@@ -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"]}

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);
 

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) {
+    }, function (_connectorsSqlSqlConnector) {
-      ZabbixDBConnector = _connectorsSqlZabbixDBConnector.ZabbixDBConnector;
+      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 () {
-
+        function Zabbix(options, backendSrv, datasourceSrv) {
-        /** @ngInject */
-        function Zabbix(url, 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;

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();
       }

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;
+  }
+}

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;

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;

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, ' ');
+}

src/datasource-zabbix/zabbix/connectors/sql/zabbixDBConnector.js

@@ -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
-`;

src/datasource-zabbix/zabbix/connectors/zabbixConnector.js

@@ -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() {}
-}

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);
     }