Services refactor - using ES6 modules.

Gruntfile.js

@@ -19,9 +19,11 @@ module.exports = function(grunt) {
           '!**/module.js',
           '!**/query.controller.js',
           '!**/utils.js',
+          '!**/DataProcessor.js',
           '!**/zabbixAPICore.service.js',
           '!**/zabbixAPI.service.js',
-          //'!**/dataProcessing.service.js',
+          '!**/queryProcessor.service.js',
+          '!**/zabbixCache.service.js',
           '!**/metricFunctions.js',
           '!**/*.scss'
         ],
@@ -57,9 +59,11 @@ module.exports = function(grunt) {
             '**/**/datasource.js',
             '**/**/query.controller.js',
             '**/**/utils.js',
+            '**/**/DataProcessor.js',
             '**/**/zabbixAPICore.service.js',
             '**/**/zabbixAPI.service.js',
-            //'**/**/dataProcessing.service.js',
+            '**/**/queryProcessor.service.js',
+            '**/**/zabbixCache.service.js',
             '**/**/metricFunctions.js'
           ],
           dest: 'dist/'

src/datasource-zabbix/DataProcessor.js

@@ -0,0 +1,234 @@
+import _ from 'lodash';
+import * as utils from './utils';
+
+export default class DataProcessor {
+
+  /**
+   * Downsample datapoints series
+   */
+  static downsampleSeries(datapoints, time_to, ms_interval, func) {
+    var downsampledSeries = [];
+    var timeWindow = {
+      from: time_to * 1000 - ms_interval,
+      to: time_to * 1000
+    };
+
+    var points_sum = 0;
+    var points_num = 0;
+    var value_avg = 0;
+    var frame = [];
+
+    for (var i = datapoints.length - 1; i >= 0; i -= 1) {
+      if (timeWindow.from < datapoints[i][1] && datapoints[i][1] <= timeWindow.to) {
+        points_sum += datapoints[i][0];
+        points_num++;
+        frame.push(datapoints[i][0]);
+      }
+      else {
+        value_avg = points_num ? points_sum / points_num : 0;
+
+        if (func === "max") {
+          downsampledSeries.push([_.max(frame), timeWindow.to]);
+        }
+        else if (func === "min") {
+          downsampledSeries.push([_.min(frame), timeWindow.to]);
+        }
+
+        // avg by default
+        else {
+          downsampledSeries.push([value_avg, timeWindow.to]);
+        }
+
+        // Shift time window
+        timeWindow.to = timeWindow.from;
+        timeWindow.from -= ms_interval;
+
+        points_sum = 0;
+        points_num = 0;
+        frame = [];
+
+        // Process point again
+        i++;
+      }
+    }
+    return downsampledSeries.reverse();
+  }
+
+  /**
+   * Group points by given time interval
+   * datapoints: [[<value>, <unixtime>], ...]
+   */
+  static groupBy(interval, groupByCallback, datapoints) {
+    var ms_interval = utils.parseInterval(interval);
+
+    // Calculate frame timestamps
+    var frames = _.groupBy(datapoints, function(point) {
+      // Calculate time for group of points
+      return Math.floor(point[1] / ms_interval) * ms_interval;
+    });
+
+    // frame: { '<unixtime>': [[<value>, <unixtime>], ...] }
+    // return [{ '<unixtime>': <value> }, { '<unixtime>': <value> }, ...]
+    var grouped = _.mapValues(frames, function(frame) {
+      var points = _.map(frame, function(point) {
+        return point[0];
+      });
+      return groupByCallback(points);
+    });
+
+    // Convert points to Grafana format
+    return sortByTime(_.map(grouped, function(value, timestamp) {
+      return [Number(value), Number(timestamp)];
+    }));
+  }
+
+  static sumSeries(timeseries) {
+
+    // Calculate new points for interpolation
+    var new_timestamps = _.uniq(_.map(_.flatten(timeseries, true), function(point) {
+      return point[1];
+    }));
+    new_timestamps = _.sortBy(new_timestamps);
+
+    var interpolated_timeseries = _.map(timeseries, function(series) {
+      var timestamps = _.map(series, function(point) {
+        return point[1];
+      });
+      var new_points = _.map(_.difference(new_timestamps, timestamps), function(timestamp) {
+        return [null, timestamp];
+      });
+      var new_series = series.concat(new_points);
+      return sortByTime(new_series);
+    });
+
+    _.each(interpolated_timeseries, interpolateSeries);
+
+    var new_timeseries = [];
+    var sum;
+    for (var i = new_timestamps.length - 1; i >= 0; i--) {
+      sum = 0;
+      for (var j = interpolated_timeseries.length - 1; j >= 0; j--) {
+        sum += interpolated_timeseries[j][i][0];
+      }
+      new_timeseries.push([sum, new_timestamps[i]]);
+    }
+
+    return sortByTime(new_timeseries);
+  }
+
+  static AVERAGE(values) {
+    var sum = 0;
+    _.each(values, function(value) {
+      sum += value;
+    });
+    return sum / values.length;
+  }
+
+  static MIN(values) {
+    return _.min(values);
+  }
+
+  static MAX(values) {
+    return _.max(values);
+  }
+
+  static MEDIAN(values) {
+    var sorted = _.sortBy(values);
+    return sorted[Math.floor(sorted.length / 2)];
+  }
+
+  static setAlias(alias, timeseries) {
+    timeseries.target = alias;
+    return timeseries;
+  }
+
+  static groupByWrapper(interval, groupFunc, datapoints) {
+    var groupByCallback = DataProcessor.aggregationFunctions[groupFunc];
+    return DataProcessor.groupBy(interval, groupByCallback, datapoints);
+  }
+
+  static aggregateWrapper(groupByCallback, interval, datapoints) {
+    var flattenedPoints = _.flatten(datapoints, true);
+    return DataProcessor.groupBy(interval, groupByCallback, flattenedPoints);
+  }
+
+  static get aggregationFunctions() {
+    return {
+      avg: this.AVERAGE,
+      min: this.MIN,
+      max: this.MAX,
+      median: this.MEDIAN
+    };
+  }
+
+  static get metricFunctions() {
+    return {
+      groupBy: this.groupByWrapper,
+      average: _.partial(this.aggregateWrapper, this.AVERAGE),
+      min: _.partial(this.aggregateWrapper, this.MIN),
+      max: _.partial(this.aggregateWrapper, this.MAX),
+      median: _.partial(this.aggregateWrapper, this.MEDIAN),
+      sumSeries: this.sumSeries,
+      setAlias: this.setAlias,
+    };
+  }
+}
+
+function sortByTime(series) {
+  return _.sortBy(series, function(point) {
+    return point[1];
+  });
+}
+
+/**
+ * Interpolate series with gaps
+ */
+function interpolateSeries(series) {
+  var left, right;
+
+  // Interpolate series
+  for (var i = series.length - 1; i >= 0; i--) {
+    if (!series[i][0]) {
+      left = findNearestLeft(series, series[i]);
+      right = findNearestRight(series, series[i]);
+      if (!left) {
+        left = right;
+      }
+      if (!right) {
+        right = left;
+      }
+      series[i][0] = linearInterpolation(series[i][1], left, right);
+    }
+  }
+  return series;
+}
+
+function linearInterpolation(timestamp, left, right) {
+  if (left[1] === right[1]) {
+    return (left[0] + right[0]) / 2;
+  } else {
+    return (left[0] + (right[0] - left[0]) / (right[1] - left[1]) * (timestamp - left[1]));
+  }
+}
+
+function findNearestRight(series, point) {
+  var point_index = _.indexOf(series, point);
+  var nearestRight;
+  for (var i = point_index; i < series.length; i++) {
+    if (series[i][0]) {
+      return series[i];
+    }
+  }
+  return nearestRight;
+}
+
+function findNearestLeft(series, point) {
+  var point_index = _.indexOf(series, point);
+  var nearestLeft;
+  for (var i = point_index; i > 0; i--) {
+    if (series[i][0]) {
+      return series[i];
+    }
+  }
+  return nearestLeft;
+}

src/datasource-zabbix/dataProcessing.service.js

@@ -1,241 +0,0 @@
-define([
-  'angular',
-  'lodash',
-  'moment',
-  './utils'
-],
-function (angular, _, moment, utils) {
-  'use strict';
-
-  var module = angular.module('grafana.services');
-
-  module.service('DataProcessingService', function() {
-    var self = this;
-
-    /**
-     * Downsample datapoints series
-     */
-    this.downsampleSeries = function(datapoints, time_to, ms_interval, func) {
-      var downsampledSeries = [];
-      var timeWindow = {
-        from: time_to * 1000 - ms_interval,
-        to: time_to * 1000
-      };
-
-      var points_sum = 0;
-      var points_num = 0;
-      var value_avg = 0;
-      var frame = [];
-
-      for (var i = datapoints.length - 1; i >= 0; i -= 1) {
-        if (timeWindow.from < datapoints[i][1] && datapoints[i][1] <= timeWindow.to) {
-          points_sum += datapoints[i][0];
-          points_num++;
-          frame.push(datapoints[i][0]);
-        }
-        else {
-          value_avg = points_num ? points_sum / points_num : 0;
-
-          if (func === "max") {
-            downsampledSeries.push([_.max(frame), timeWindow.to]);
-          }
-          else if (func === "min") {
-            downsampledSeries.push([_.min(frame), timeWindow.to]);
-          }
-
-          // avg by default
-          else {
-            downsampledSeries.push([value_avg, timeWindow.to]);
-          }
-
-          // Shift time window
-          timeWindow.to = timeWindow.from;
-          timeWindow.from -= ms_interval;
-
-          points_sum = 0;
-          points_num = 0;
-          frame = [];
-
-          // Process point again
-          i++;
-        }
-      }
-      return downsampledSeries.reverse();
-    };
-
-    /**
-     * Group points by given time interval
-     * datapoints: [[<value>, <unixtime>], ...]
-     */
-    this.groupBy = function(interval, groupByCallback, datapoints) {
-      var ms_interval = utils.parseInterval(interval);
-
-      // Calculate frame timestamps
-      var frames = _.groupBy(datapoints, function(point) {
-        // Calculate time for group of points
-        return Math.floor(point[1] / ms_interval) * ms_interval;
-      });
-
-      // frame: { '<unixtime>': [[<value>, <unixtime>], ...] }
-      // return [{ '<unixtime>': <value> }, { '<unixtime>': <value> }, ...]
-      var grouped = _.mapValues(frames, function(frame) {
-        var points = _.map(frame, function(point) {
-          return point[0];
-        });
-        return groupByCallback(points);
-      });
-
-      // Convert points to Grafana format
-      return sortByTime(_.map(grouped, function(value, timestamp) {
-        return [Number(value), Number(timestamp)];
-      }));
-    };
-
-    this.sumSeries = function(timeseries) {
-
-      // Calculate new points for interpolation
-      var new_timestamps = _.uniq(_.map(_.flatten(timeseries, true), function(point) {
-        return point[1];
-      }));
-      new_timestamps = _.sortBy(new_timestamps);
-
-      var interpolated_timeseries = _.map(timeseries, function(series) {
-        var timestamps = _.map(series, function(point) {
-          return point[1];
-        });
-        var new_points = _.map(_.difference(new_timestamps, timestamps), function(timestamp) {
-          return [null, timestamp];
-        });
-        var new_series = series.concat(new_points);
-        return sortByTime(new_series);
-      });
-
-      _.each(interpolated_timeseries, interpolateSeries);
-
-      var new_timeseries = [];
-      var sum;
-      for (var i = new_timestamps.length - 1; i >= 0; i--) {
-        sum = 0;
-        for (var j = interpolated_timeseries.length - 1; j >= 0; j--) {
-          sum += interpolated_timeseries[j][i][0];
-        }
-        new_timeseries.push([sum, new_timestamps[i]]);
-      }
-
-      return sortByTime(new_timeseries);
-    };
-
-    function sortByTime(series) {
-      return _.sortBy(series, function(point) {
-        return point[1];
-      });
-    }
-
-    /**
-     * Interpolate series with gaps
-     */
-    function interpolateSeries(series) {
-      var left, right;
-
-      // Interpolate series
-      for (var i = series.length - 1; i >= 0; i--) {
-        if (!series[i][0]) {
-          left = findNearestLeft(series, series[i]);
-          right = findNearestRight(series, series[i]);
-          if (!left) {
-            left = right;
-          }
-          if (!right) {
-            right = left;
-          }
-          series[i][0] = linearInterpolation(series[i][1], left, right);
-        }
-      }
-      return series;
-    }
-
-    function linearInterpolation(timestamp, left, right) {
-      if (left[1] === right[1]) {
-        return (left[0] + right[0]) / 2;
-      } else {
-        return (left[0] + (right[0] - left[0]) / (right[1] - left[1]) * (timestamp - left[1]));
-      }
-    }
-
-    function findNearestRight(series, point) {
-      var point_index = _.indexOf(series, point);
-      var nearestRight;
-      for (var i = point_index; i < series.length; i++) {
-        if (series[i][0]) {
-          return series[i];
-        }
-      }
-      return nearestRight;
-    }
-
-    function findNearestLeft(series, point) {
-      var point_index = _.indexOf(series, point);
-      var nearestLeft;
-      for (var i = point_index; i > 0; i--) {
-        if (series[i][0]) {
-          return series[i];
-        }
-      }
-      return nearestLeft;
-    }
-
-    this.AVERAGE = function(values) {
-      var sum = 0;
-      _.each(values, function(value) {
-        sum += value;
-      });
-      return sum / values.length;
-    };
-
-    this.MIN = function(values) {
-      return _.min(values);
-    };
-
-    this.MAX = function(values) {
-      return _.max(values);
-    };
-
-    this.MEDIAN = function(values) {
-      var sorted = _.sortBy(values);
-      return sorted[Math.floor(sorted.length / 2)];
-    };
-
-    this.setAlias = function(alias, timeseries) {
-      timeseries.target = alias;
-      return timeseries;
-    };
-
-    this.aggregationFunctions = {
-      avg: this.AVERAGE,
-      min: this.MIN,
-      max: this.MAX,
-      median: this.MEDIAN
-    };
-
-    this.groupByWrapper = function(interval, groupFunc, datapoints) {
-      var groupByCallback = self.aggregationFunctions[groupFunc];
-      return self.groupBy(interval, groupByCallback, datapoints);
-    };
-
-    this.aggregateWrapper = function(groupByCallback, interval, datapoints) {
-      var flattenedPoints = _.flatten(datapoints, true);
-      return self.groupBy(interval, groupByCallback, flattenedPoints);
-    };
-
-    this.metricFunctions = {
-      groupBy: this.groupByWrapper,
-      average: _.partial(this.aggregateWrapper, this.AVERAGE),
-      min: _.partial(this.aggregateWrapper, this.MIN),
-      max: _.partial(this.aggregateWrapper, this.MAX),
-      median: _.partial(this.aggregateWrapper, this.MEDIAN),
-      sumSeries: this.sumSeries,
-      setAlias: this.setAlias,
-    };
-
-  });
-});

src/datasource-zabbix/datasource.js

@@ -3,15 +3,15 @@ import _ from 'lodash';
 import * as dateMath from 'app/core/utils/datemath';
 import * as utils from './utils';
 import * as metricFunctions from './metricFunctions';
+import DataProcessor from './DataProcessor';
 import './zabbixAPI.service.js';
 import './zabbixCache.service.js';
 import './queryProcessor.service.js';
-import './dataProcessing.service';
 
 export class ZabbixAPIDatasource {
 
   /** @ngInject */
-  constructor(instanceSettings, $q, templateSrv, alertSrv, zabbixAPIService, ZabbixCachingProxy, QueryProcessor, DataProcessingService) {
+  constructor(instanceSettings, $q, templateSrv, alertSrv, zabbixAPIService, ZabbixCachingProxy, QueryProcessor) {
 
     // General data source settings
     this.name             = instanceSettings.name;
@@ -45,7 +45,6 @@ export class ZabbixAPIDatasource {
     this.q = $q;
     this.templateSrv = templateSrv;
     this.alertSrv = alertSrv;
-    this.DataProcessingService = DataProcessingService;
 
     console.log(this.zabbixCache);
   }
@@ -159,7 +158,7 @@ export class ZabbixAPIDatasource {
                 timeseries_data = _.map(timeseries_data, function (timeseries) {
 
                   // Filter only transform functions
-                  var transformFunctions = bindFunctionDefs(target.functions, 'Transform', self.DataProcessingService);
+                  var transformFunctions = bindFunctionDefs(target.functions, 'Transform', DataProcessor);
 
                   // Metric data processing
                   var dp = timeseries.datapoints;
@@ -172,7 +171,7 @@ export class ZabbixAPIDatasource {
                 });
 
                 // Aggregations
-                var aggregationFunctions = bindFunctionDefs(target.functions, 'Aggregate', self.DataProcessingService);
+                var aggregationFunctions = bindFunctionDefs(target.functions, 'Aggregate', DataProcessor);
                 var dp = _.map(timeseries_data, 'datapoints');
                 if (aggregationFunctions.length) {
                   for (var i = 0; i < aggregationFunctions.length; i++) {
@@ -189,7 +188,7 @@ export class ZabbixAPIDatasource {
                 }
 
                 // Apply alias functions
-                var aliasFunctions = bindFunctionDefs(target.functions, 'Alias', self.DataProcessingService);
+                var aliasFunctions = bindFunctionDefs(target.functions, 'Alias', DataProcessor);
                 for (var j = 0; j < aliasFunctions.length; j++) {
                   _.each(timeseries_data, aliasFunctions[j]);
                 }
@@ -255,9 +254,9 @@ export class ZabbixAPIDatasource {
 
         // Series downsampling
         var data = _.map(timeseries_data, function(timeseries) {
-          var DPS = self.DataProcessingService;
           if (timeseries.datapoints.length > options.maxDataPoints) {
-            timeseries.datapoints = DPS.groupBy(options.interval, DPS.AVERAGE, timeseries.datapoints);
+            timeseries.datapoints =
+              DataProcessor.groupBy(options.interval, DataProcessor.AVERAGE, timeseries.datapoints);
           }
           return timeseries;
         });
@@ -409,7 +408,7 @@ export class ZabbixAPIDatasource {
 
 }
 
-function bindFunctionDefs(functionDefs, category, DataProcessingService) {
+function bindFunctionDefs(functionDefs, category, DataProcessor) {
   'use strict';
   var aggregationFunctions = _.map(metricFunctions.getCategories()[category], 'name');
   var aggFuncDefs = _.filter(functionDefs, function(func) {
@@ -418,7 +417,7 @@ function bindFunctionDefs(functionDefs, category, DataProcessingService) {
 
   return _.map(aggFuncDefs, function(func) {
     var funcInstance = metricFunctions.createFuncInstance(func.def, func.params);
-    return funcInstance.bindFunction(DataProcessingService.metricFunctions);
+    return funcInstance.bindFunction(DataProcessor.metricFunctions);
   });
 }
 

src/datasource-zabbix/queryProcessor.service.js

@@ -1,57 +1,56 @@
-define([
+import angular from 'angular';
-  'angular',
+import _ from 'lodash';
-  'lodash',
+import * as utils from './utils';
-  './utils'
-],
-function (angular, _, utils) {
-  'use strict';
 
-  var module = angular.module('grafana.services');
+/** @ngInject */
-
+angular.module('grafana.services').factory('QueryProcessor', function($q) {
-  module.factory('QueryProcessor', function($q) {
-
-    function QueryProcessor(zabbixCacheInstance) {
-      var self = this;
 
+  class QueryProcessor {
+    constructor(zabbixCacheInstance) {
       this.cache = zabbixCacheInstance;
+      this.$q = $q;
+    }
 
     /**
      * Build query in asynchronous manner
      */
-      this.build = function (groupFilter, hostFilter, appFilter, itemFilter) {
+    build(groupFilter, hostFilter, appFilter, itemFilter) {
+      var self = this;
       if (this.cache._initialized) {
-          return $q.when(self.buildFromCache(groupFilter, hostFilter, appFilter, itemFilter));
+        return this.$q.when(self.buildFromCache(groupFilter, hostFilter, appFilter, itemFilter));
       } else {
         return this.cache.refresh().then(function() {
           return self.buildFromCache(groupFilter, hostFilter, appFilter, itemFilter);
         });
       }
-      };
+    }
 
     /**
      * Build trigger query in asynchronous manner
      */
-      this.buildTriggerQuery = function (groupFilter, hostFilter, appFilter) {
+    buildTriggerQuery(groupFilter, hostFilter, appFilter) {
+      var self = this;
       if (this.cache._initialized) {
-          return $q.when(self.buildTriggerQueryFromCache(groupFilter, hostFilter, appFilter));
+        return this.$q.when(self.buildTriggerQueryFromCache(groupFilter, hostFilter, appFilter));
       } else {
         return this.cache.refresh().then(function() {
           return self.buildTriggerQueryFromCache(groupFilter, hostFilter, appFilter);
         });
       }
-      };
+    }
 
-      this.filterGroups = function(groupFilter) {
+    filterGroups(groupFilter) {
       return this.cache.getGroups().then(function(groupList) {
         return groupList;
       });
-      };
+    }
 
     /**
      * Get list of host belonging to given groups.
      * @return list of hosts
      */
-      this.filterHosts = function(groupFilter) {
+    filterHosts(groupFilter) {
+      var self = this;
       return this.cache.getGroups().then(function(groups) {
         groups = findByFilter(groups, groupFilter);
         var hostids = _.flatten(_.map(groups, 'hosts'));
@@ -65,19 +64,19 @@ function (angular, _, utils) {
           return [];
         }
       });
-      };
+    }
 
     /**
      * Get list of applications belonging to given groups and hosts.
      * @return  list of applications belonging to given hosts
      */
-      this.filterApplications = function(groupFilter, hostFilter) {
+    filterApplications(groupFilter, hostFilter) {
       var promises = [
         this.filterHosts(groupFilter),
         this.cache.getApplications()
       ];
 
-        return $q.all(promises).then(function(results) {
+      return this.$q.all(promises).then(function(results) {
         var hostList = results[0];
         var applicationList = results[1];
 
@@ -91,9 +90,9 @@ function (angular, _, utils) {
           return [];
         }
       });
-      };
+    }
 
-      this.filterItems = function (groupFilter, hostFilter, appFilter, itemType, showDisabledItems) {
+    filterItems(groupFilter, hostFilter, appFilter, itemType, showDisabledItems) {
       var hosts;
       var apps;
       var items;
@@ -105,7 +104,7 @@ function (angular, _, utils) {
         this.cache.getIndexedApplications()
       ];
 
-        return $q.all(promises).then(function(results) {
+      return this.$q.all(promises).then(function(results) {
         var hostList = results[0];
         var applicationList = results[1];
         var idx_hosts = results[2];
@@ -150,12 +149,12 @@ function (angular, _, utils) {
 
         return items;
       });
-      };
+    }
 
     /**
      * Build query - convert target filters to array of Zabbix items
      */
-      this.buildFromCache = function (groupFilter, hostFilter, appFilter, itemFilter) {
+    buildFromCache(groupFilter, hostFilter, appFilter, itemFilter) {
       return this.filterItems(groupFilter, hostFilter, appFilter).then(function(items) {
         if (items.length) {
           if (utils.isRegex(itemFilter)) {
@@ -167,12 +166,12 @@ function (angular, _, utils) {
           return [];
         }
       });
-      };
+    }
 
     /**
      * Build query - convert target filters to array of Zabbix items
      */
-      this.buildTriggerQueryFromCache = function (groupFilter, hostFilter, appFilter) {
+    buildTriggerQueryFromCache(groupFilter, hostFilter, appFilter) {
       var promises = [
         this.cache.getGroups().then(function(groups) {
           return _.filter(groups, function(group) {
@@ -203,7 +202,7 @@ function (angular, _, utils) {
         })
       ];
 
-        return $q.all(promises).then(function(results) {
+      return this.$q.all(promises).then(function(results) {
         var filteredGroups = results[0];
         var filteredHosts = results[1];
         var filteredApps = results[2];
@@ -221,7 +220,7 @@ function (angular, _, utils) {
 
         return query;
       });
-      };
+    }
 
     /**
      * Convert Zabbix API history.get response to Grafana format
@@ -232,7 +231,7 @@ function (angular, _, utils) {
      *                               datapoints: [[<value>, <unixtime>], ...]
      *                            }
      */
-      this.convertHistory = function(history, addHostName, convertPointCallback) {
+    convertHistory(history, addHostName, convertPointCallback) {
       /**
        * Response should be in the format:
        * data: [
@@ -242,6 +241,7 @@ function (angular, _, utils) {
        *          }, ...
        *       ]
        */
+      var self = this;
 
       // Group history by itemid
       var grouped_history = _.groupBy(history, 'itemid');
@@ -258,18 +258,18 @@ function (angular, _, utils) {
           datapoints: _.map(hist, convertPointCallback)
         };
       });
-      };
+    }
 
-      this.handleHistory = function(history, addHostName) {
+    handleHistory(history, addHostName) {
       return this.convertHistory(history, addHostName, convertHistoryPoint);
-      };
+    }
 
-      this.handleTrends = function(history, addHostName, valueType) {
+    handleTrends(history, addHostName, valueType) {
       var convertPointCallback = _.partial(convertTrendPoint, valueType);
       return this.convertHistory(history, addHostName, convertPointCallback);
-      };
+    }
 
-      this.handleSLAResponse = function (itservice, slaProperty, slaObject) {
+    handleSLAResponse(itservice, slaProperty, slaObject) {
       var targetSLA = slaObject[itservice.serviceid].sla[0];
       if (slaProperty.property === 'status') {
         var targetStatus = parseInt(slaObject[itservice.serviceid].status);
@@ -288,7 +288,7 @@ function (angular, _, utils) {
           ]
         };
       }
-      };
+    }
   }
 
   return QueryProcessor;
@@ -359,5 +359,3 @@ function (angular, _, utils) {
     point.clock * 1000
   ];
 }
-
-});

src/datasource-zabbix/zabbixCache.service.js

@@ -1,27 +1,25 @@
-define([
+import angular from 'angular';
-  'angular',
+import _ from 'lodash';
-  'lodash',
+import * as utils from './utils';
-  './utils'
-],
-function (angular, _, utils) {
-  'use strict';
-
-  var module = angular.module('grafana.services');
 
 // Use factory() instead service() for multiple datasources support.
 // Each datasource instance must initialize its own cache.
-  module.factory('ZabbixCachingProxy', function($q, $interval) {
 
-    function ZabbixCachingProxy(zabbixAPI, ttl) {
+/** @ngInject */
+angular.module('grafana.services').factory('ZabbixCachingProxy', function($q, $interval) {
+
+  class ZabbixCachingProxy {
+    constructor(zabbixAPI, ttl) {
       this.zabbixAPI = zabbixAPI;
       this.ttl = ttl;
 
+      this.$q = $q;
+
       // Internal objects for data storing
       this._groups        = undefined;
       this._hosts         = undefined;
       this._applications  = undefined;
       this._items         = undefined;
-      this._hostsExtend   = undefined;
       this.storage = {
         history: {},
         trends: {}
@@ -34,7 +32,7 @@ function (angular, _, utils) {
       this.historyPromises = {};
 
       // Wrap _refresh() method to call it once.
-      this.refresh = callOnce(p._refresh, this.refreshPromise);
+      this.refresh = callOnce(this._refresh, this.refreshPromise);
 
       // Update cache periodically
       $interval(_.bind(this.refresh, this), this.ttl);
@@ -44,9 +42,7 @@ function (angular, _, utils) {
                                         this.historyPromises);
     }
 
-    var p = ZabbixCachingProxy.prototype;
+    _refresh() {
-
-    p._refresh = function() {
       var self = this;
       var promises = [
         this.zabbixAPI.getGroups(),
@@ -56,7 +52,7 @@ function (angular, _, utils) {
         this.zabbixAPI.getHostsExtend()
       ];
 
-      return $q.all(promises).then(function(results) {
+      return this.$q.all(promises).then(function(results) {
         if (results.length) {
           self._groups        = convertGroups(results[0]);
           self._hosts         = convertHosts(results[1]);
@@ -67,94 +63,76 @@ function (angular, _, utils) {
         }
         self._initialized = true;
       });
-    };
+    }
 
-    p.getGroups = function() {
+    getGroups() {
       var self = this;
       if (this._groups) {
-        return $q.when(self._groups);
+        return this.$q.when(self._groups);
       } else {
         return this.refresh().then(function() {
           return self._groups;
         });
       }
-    };
+    }
 
-    p.getHosts = function() {
+    getHosts() {
       var self = this;
       if (this._hosts) {
-        return $q.when(self._hosts);
+        return this.$q.when(self._hosts);
       } else {
         return this.refresh().then(function() {
           return self._hosts;
         });
       }
-    };
+    }
 
-    p.getIndexedHosts = function() {
+    getIndexedHosts() {
       var self = this;
       if (this._idx_hosts) {
-        return $q.when(self._idx_hosts);
+        return this.$q.when(self._idx_hosts);
       } else {
         return this.refresh().then(function() {
           return self._idx_hosts;
         });
       }
-    };
+    }
 
-    p.getIndexedApplications = function() {
+    getIndexedApplications() {
       var self = this;
       if (this._idx_apps) {
-        return $q.when(self._idx_apps);
+        return this.$q.when(self._idx_apps);
       } else {
         return this.refresh().then(function() {
           return self._idx_apps;
         });
       }
-    };
+    }
 
-    p.getApplications = function() {
+    getApplications() {
       var self = this;
       if (this._applications) {
-        return $q.when(self._applications);
+        return this.$q.when(self._applications);
       } else {
         return this.refresh().then(function() {
           return self._applications;
         });
       }
-    };
+    }
 
-    p.getItems = function(type) {
+    getItems(type) {
       var self = this;
       if (this._items) {
-        return $q.when(filterItems(self._items, type));
+        return this.$q.when(filterItems(self._items, type));
       } else {
         return this.refresh().then(function() {
           return filterItems(self._items, type);
         });
       }
-    };
-
-    function filterItems(items, type) {
-      switch (type) {
-        case 'num':
-          return _.filter(items, function(item) {
-            return (item.value_type === '0' ||
-                    item.value_type === '3');
-          });
-        case 'text':
-          return _.filter(items, function(item) {
-            return (item.value_type === '1' ||
-                    item.value_type === '2' ||
-                    item.value_type === '4');
-          });
-        default:
-          return items;
-      }
     }
 
-    p.getHistoryFromCache = function(items, time_from, time_till) {
+    getHistoryFromCache(items, time_from, time_till) {
-      var deferred  = $q.defer();
+      var deferred  = this.$q.defer();
       var historyStorage = this.storage.history;
       var full_history;
       var expired = _.filter(_.indexBy(items, 'itemid'), function(item, itemid) {
@@ -182,19 +160,59 @@ function (angular, _, utils) {
         deferred.resolve(_.flatten(full_history, true));
       }
       return deferred.promise;
-    };
+    }
 
-    p.getHistoryFromAPI = function(items, time_from, time_till) {
+    getHistoryFromAPI(items, time_from, time_till) {
       return this.zabbixAPI.getHistory(items, time_from, time_till);
-    };
+    }
 
-    p.getHost = function(hostid) {
+    getHost(hostid) {
       return _.find(this._hosts, {'hostid': hostid});
-    };
+    }
 
-    p.getItem = function(itemid) {
+    getItem(itemid) {
       return _.find(this._items, {'itemid': itemid});
+    }
+  }
+
+  function callHistoryOnce(func, promiseKeeper) {
+    return function() {
+      var itemids = _.map(arguments[0], 'itemid');
+      var stamp = itemids.join() + arguments[1] + arguments[2];
+      var hash = stamp.getHash();
+
+      var deferred  = $q.defer();
+      if (!promiseKeeper[hash]) {
+        promiseKeeper[hash] = deferred.promise;
+        func.apply(this, arguments).then(function(result) {
+          deferred.resolve(result);
+          promiseKeeper[hash] = null;
+        });
+      } else {
+        return promiseKeeper[hash];
+      }
+      return deferred.promise;
     };
+  }
+
+  function callOnce(func, promiseKeeper) {
+    return function() {
+      var deferred  = $q.defer();
+      if (!promiseKeeper) {
+        promiseKeeper = deferred.promise;
+        func.apply(this, arguments).then(function(result) {
+          deferred.resolve(result);
+          promiseKeeper = null;
+        });
+      } else {
+        return promiseKeeper;
+      }
+      return deferred.promise;
+    };
+  }
+
+  return ZabbixCachingProxy;
+});
 
 /**
  * Convert host.get response to cache format
@@ -286,6 +304,24 @@ function (angular, _, utils) {
   });
 }
 
+function filterItems(items, type) {
+  switch (type) {
+    case 'num':
+      return _.filter(items, function(item) {
+        return (item.value_type === '0' ||
+                item.value_type === '3');
+      });
+    case 'text':
+      return _.filter(items, function(item) {
+        return (item.value_type === '1' ||
+                item.value_type === '2' ||
+                item.value_type === '4');
+      });
+    default:
+      return items;
+  }
+}
+
 String.prototype.getHash = function() {
   var hash = 0, i, chr, len;
   if (this.length === 0) {
@@ -298,45 +334,3 @@ function (angular, _, utils) {
   }
   return hash;
 };
-
-    function callHistoryOnce(func, promiseKeeper) {
-      return function() {
-        var itemids = _.map(arguments[0], 'itemid');
-        var stamp = itemids.join() + arguments[1] + arguments[2];
-        var hash = stamp.getHash();
-
-        var deferred  = $q.defer();
-        if (!promiseKeeper[hash]) {
-          promiseKeeper[hash] = deferred.promise;
-          func.apply(this, arguments).then(function(result) {
-            deferred.resolve(result);
-            promiseKeeper[hash] = null;
-          });
-        } else {
-          return promiseKeeper[hash];
-        }
-        return deferred.promise;
-      };
-    }
-
-    function callOnce(func, promiseKeeper) {
-      return function() {
-        var deferred  = $q.defer();
-        if (!promiseKeeper) {
-          promiseKeeper = deferred.promise;
-          func.apply(this, arguments).then(function(result) {
-            deferred.resolve(result);
-            promiseKeeper = null;
-          });
-        } else {
-          return promiseKeeper;
-        }
-        return deferred.promise;
-      };
-    }
-
-    return ZabbixCachingProxy;
-
-  });
-
-});