Rewrite query builder to allow for multiple time series.

public/app/plugins/datasource/elasticsearch/datasource.js

@@ -295,46 +295,29 @@ function (angular, _, config, kbn, moment, ElasticQueryBuilder) {
     };
 
     ElasticDatasource.prototype.query = function(options) {
-      var self = this;
+      var queryBuilder = new ElasticQueryBuilder;
-      var allQueries = options.targets.map(function(target) {
+      var query = queryBuilder.build(options.targets);
-        if (target.hide) { return []; }
+      query = query.replace(/\$interval/g, options.interval);
-        var queryBuilder = new ElasticQueryBuilder(target);
-        var query = queryBuilder.build();
-        console.log(target);
-        query = query.replace(/\$interval/g, target.interval || options.interval);
       query = query.replace(/\$rangeFrom/g, options.range.from);
       query = query.replace(/\$rangeTo/g, options.range.to);
       query = query.replace(/\$maxDataPoints/g, options.maxDataPoints);
-        query = query.replace(/\$keyField/g, target.keyField);
-        query = query.replace(/\$valueField/g, target.valueField);
-        query = query.replace(/\$termKey/g, target.termKey);
-        query = query.replace(/\$termValue/g, target.termValue);
       query = templateSrv.replace(query, options.scopedVars);
-        return query;
+      return this._post('/_search?search_type=count', query).then(this._getTimeSeries);
-      }).join("\n");
-
-      console.log(allQueries);
-
-      return this._post('/_search?search_type=count', allQueries).then(function(results) {
-        if (!results || !results.facets) {
-          return { data: [] };
-        }
-        return { data: self._getTimeSeries(results.facets) };
-      });
     };
 
-    ElasticDatasource.prototype._getTimeSeries = function(facets) {
+    ElasticDatasource.prototype._getTimeSeries = function(results) {
-      var self = this;
+      var data = [];
-      var targets = ['metric'];
+      if (results && results.facets) {
-      var data = targets.map(function(target) {
+        for (var target in results.facets) {
-        var datapoints = facets[target].entries.map(self._getDatapoint);
+          if (results.facets.hasOwnProperty(target) && results.facets[target].entries) {
-        return { target: target, datapoints: datapoints };
+            var datapoints = results.facets[target].entries.map(function(entry) {
-      });
-      return data;
-    };
-
-    ElasticDatasource.prototype._getDatapoint = function(entry) {
               return [entry.mean, entry.time];
+            });
+            data.push({ target: target, datapoints: datapoints });
+          }
+        }
+      }
+      return { data: data };
     };
 
     return ElasticDatasource;

public/app/plugins/datasource/elasticsearch/queryBuilder.js

@@ -3,51 +3,51 @@ define([
 function () {
   'use strict';
 
-  function ElasticQueryBuilder(target) {
+  function ElasticQueryBuilder() {
-    this.target = target;
   }
 
-  ElasticQueryBuilder.prototype.build = function() {
+  ElasticQueryBuilder.prototype.build = function(targets) {
-    var target = this.target;
     var query = {
-      "facets": {
+      "facets": {},
-        "metric": {
+      "size": "$maxDataPoints"
+    };
+    var self = this;
+    targets.forEach(function(target) {
+      if (!target.hide) {
+        query["facets"][target.termKey + "_" + target.termValue] = {
           "date_histogram": {
-            "interval": "$interval",
+            "interval": target.interval || "$interval",
-            "key_field": "$keyField",
+            "key_field": target.keyField,
             "min_doc_count": 0,
-            "value_field": "$valueField"
+            "value_field": target.valueField
-          }
-        }
           },
-      "query": {
+          "facet_filter": {
-        "filtered": {
-          "filter": {
             "and": [
-              {
+              self._buildRangeFilter(target),
-                "range": {
+              self._buildTermFilter(target)
-                  "@timestamp": {
-                    "gte": "$rangeFrom",
-                    "lte": "$rangeTo"
-                  }
-                }
-              },
-              {
-                "term": {
-                  "$termKey": "$termValue",
-                }
-              }
             ]
           }
-        }
-      },
-      "size": "$maxDataPoints",
-      "sort": "@timestamp"
         };
+      }
+    });
     query = JSON.stringify(query);
-    target.query = query;
     return query;
   };
 
+  ElasticQueryBuilder.prototype._buildRangeFilter = function(target) {
+    var filter = {"range":{}};
+    filter["range"][target.keyField] = {
+      "gte": "$rangeFrom",
+      "lte": "$rangeTo"
+    };
+    return filter;
+  };
+
+  ElasticQueryBuilder.prototype._buildTermFilter = function(target) {
+    var filter = {"term":{}};
+    filter["term"][target.termKey] = target.termValue;
+    return filter;
+  };
+
   return ElasticQueryBuilder;
 });