[Maps] use style metadata to calculate symbolization bands

x-pack/legacy/plugins/maps/common/constants.js

@@ -57,6 +57,8 @@ export const FIELD_ORIGIN = {
 };
 
 export const SOURCE_DATA_ID_ORIGIN = 'source';
+export const META_ID_ORIGIN_SUFFIX = 'meta';
+export const SOURCE_META_ID_ORIGIN = `${SOURCE_DATA_ID_ORIGIN}_${META_ID_ORIGIN_SUFFIX}`;
 
 export const GEOJSON_FILE = 'GEOJSON_FILE';
 

x-pack/legacy/plugins/maps/public/layers/fields/es_agg_field.js

@@ -6,7 +6,7 @@
 
 
 import { AbstractField } from './field';
-import { COUNT_AGG_TYPE } from '../../../common/constants';
+import { COUNT_AGG_TYPE, METRIC_TYPE } from '../../../common/constants';
 import { ESAggMetricTooltipProperty } from '../tooltips/es_aggmetric_tooltip_property';
 
 export class ESAggMetricField extends AbstractField {
@@ -55,7 +55,6 @@ export class ESAggMetricField extends AbstractField {
     );
   }
 
-
   makeMetricAggConfig() {
     const metricAggConfig = {
       id: this.getName(),
@@ -69,4 +68,13 @@ export class ESAggMetricField extends AbstractField {
     }
     return metricAggConfig;
   }
+
+  supportsFieldMeta() {
+    // count and sum aggregations are not within field bounds so they do not support field meta.
+    return ![METRIC_TYPE.COUNT, METRIC_TYPE.SUM, METRIC_TYPE.UNIQUE_COUNT].includes(this.getAggType());
+  }
+
+  async getFieldMetaRequest(config) {
+    return this._esDocField.getFieldMetaRequest(config);
+  }
 }

x-pack/legacy/plugins/maps/public/layers/fields/es_doc_field.js

@@ -27,4 +27,31 @@ export class ESDocField extends AbstractField {
     return field.type;
   }
 
+  supportsFieldMeta() {
+    return true;
+  }
+
+  async getFieldMetaRequest({ sigma }) {
+    const field = await this._getField();
+
+    if (field.type === 'number') {
+      const extendedStats = { sigma };
+      if (field.scripted) {
+        extendedStats.script = {
+          source: field.script,
+          lang: field.lang
+        };
+      } else {
+        extendedStats.field = this._fieldName;
+      }
+      return {
+        [`${this._fieldName}_range_stats`]: {
+          extended_stats: extendedStats
+        }
+      };
+    }
+
+    return null;
+  }
+
 }

x-pack/legacy/plugins/maps/public/layers/fields/field.js

@@ -42,4 +42,12 @@ export class AbstractField {
   getOrigin() {
     return this._origin;
   }
+
+  supportsFieldMeta() {
+    return false;
+  }
+
+  async getFieldMetaRequest(/* config */) {
+    return null;
+  }
 }

x-pack/legacy/plugins/maps/public/layers/layer.js

@@ -85,7 +85,7 @@ export class AbstractLayer {
   }
 
   supportsElasticsearchFilters() {
-    return this._source.supportsElasticsearchFilters();
+    return this._source.isElasticsearchSource();
   }
 
   async supportsFitToBounds() {

x-pack/legacy/plugins/maps/public/layers/sources/es_source.js

@@ -54,7 +54,7 @@ export class AbstractESSource extends AbstractVectorSource {
     return [];
   }
 
-  supportsElasticsearchFilters() {
+  isElasticsearchSource() {
     return true;
   }
 
@@ -73,7 +73,7 @@ export class AbstractESSource extends AbstractVectorSource {
     return [];
   }
 
-  async _runEsQuery(requestName, searchSource, registerCancelCallback, requestDescription) {
+  async _runEsQuery(requestName, searchSource, registerCancelCallback, requestDescription, requestId) {
     const abortController = new AbortController();
     registerCancelCallback(() => abortController.abort());
 
@@ -82,7 +82,7 @@ export class AbstractESSource extends AbstractVectorSource {
         inspectorAdapters: this._inspectorAdapters,
         searchSource,
         requestName,
-        requestId: this.getId(),
+        requestId: requestId ? requestId : this.getId(),
         requestDesc: requestDescription,
         abortSignal: abortController.signal,
       });
@@ -271,4 +271,43 @@ export class AbstractESSource extends AbstractVectorSource {
     return fieldFromIndexPattern.format.getConverterFor('text');
   }
 
+  async loadStylePropsMeta(layerName, dynamicStyleProps, registerCancelCallback) {
+    const promises = dynamicStyleProps
+      .map(dynamicStyleProp => {
+        return dynamicStyleProp.getFieldMetaRequest();
+      });
+
+    const fieldAggRequests = await Promise.all(promises);
+    const aggs = fieldAggRequests.reduce((aggs, fieldAggRequest) => {
+      if (!fieldAggRequest) {
+        return aggs;
+      }
+
+      return {
+        ...aggs,
+        ...fieldAggRequest,
+      };
+    }, {});
+
+    const indexPattern = await this.getIndexPattern();
+    const searchSource = new SearchSource();
+    searchSource.setField('index', indexPattern);
+    searchSource.setField('size', 0);
+    searchSource.setField('aggs', aggs);
+
+    const resp = await this._runEsQuery(
+      i18n.translate('xpack.maps.source.esSource.stylePropsMetaRequestName', {
+        defaultMessage: '{layerName} - metadata',
+        values: { layerName }
+      }),
+      searchSource,
+      registerCancelCallback,
+      i18n.translate('xpack.maps.source.esSource.stylePropsMetaRequestDescription', {
+        defaultMessage: 'Elasticsearch request retrieving field metadata used for calculating symbolization bands.',
+      }),
+      `${this.getId()}_styleMeta`);
+
+    return resp;
+  }
+
 }

x-pack/legacy/plugins/maps/public/layers/sources/source.js

@@ -123,7 +123,7 @@ export class AbstractSource {
     return AbstractSource.isIndexingSource;
   }
 
-  supportsElasticsearchFilters() {
+  isElasticsearchSource() {
     return false;
   }
 
@@ -136,6 +136,10 @@ export class AbstractSource {
   async getFieldFormatter(/* fieldName */) {
     return null;
   }
+
+  async loadStylePropsMeta() {
+    throw new Error(`Source#loadStylePropsMeta not implemented`);
+  }
 }
 
 

x-pack/legacy/plugins/maps/public/layers/styles/vector/properties/dynamic_style_property.js

@@ -32,6 +32,14 @@ export class DynamicStyleProperty extends AbstractStyleProperty {
       return this._field.getOrigin();
     }
 
+    supportsFieldMeta() {
+      return this._field.supportsFieldMeta();
+    }
+
+    async getFieldMetaRequest() {
+      return this._field.getFieldMetaRequest({ sigma: 3 });
+    }
+
     supportsFeatureState() {
       return true;
     }

x-pack/legacy/plugins/maps/public/layers/vector_layer.js

@@ -13,9 +13,11 @@ import {
   GEO_JSON_TYPE,
   FEATURE_ID_PROPERTY_NAME,
   SOURCE_DATA_ID_ORIGIN,
+  SOURCE_META_ID_ORIGIN,
   FEATURE_VISIBLE_PROPERTY_NAME,
   EMPTY_FEATURE_COLLECTION,
-  LAYER_TYPE
+  LAYER_TYPE,
+  FIELD_ORIGIN,
 } from '../../common/constants';
 import _ from 'lodash';
 import { JoinTooltipProperty } from './tooltips/join_tooltip_property';
@@ -464,7 +466,7 @@ export class VectorLayer extends AbstractLayer {
     startLoading, stopLoading, onLoadError, registerCancelCallback, dataFilters
   }) {
 
-    const requestToken = Symbol(`layer-source-refresh:${this.getId()} - source`);
+    const requestToken = Symbol(`layer-source-data:${this.getId()}`);
     const searchFilters = this._getSearchFilters(dataFilters);
     const canSkip = await this._canSkipSourceUpdate(this._source, SOURCE_DATA_ID_ORIGIN, searchFilters);
     if (canSkip) {
@@ -498,6 +500,42 @@ export class VectorLayer extends AbstractLayer {
     }
   }
 
+  async _syncSourceStyleMeta({
+    startLoading, stopLoading, onLoadError, registerCancelCallback
+  }) {
+
+    if (!this._source.isElasticsearchSource()) {
+      return;
+    }
+
+    const sourceMetaDataRequest = this._findDataRequestForSource(SOURCE_META_ID_ORIGIN);
+    if (sourceMetaDataRequest) {
+      return;
+    }
+
+    const dynamicStyleProps = this._style.getDynamicPropertiesArray()
+      .filter(dynamicStyleProp => {
+        return dynamicStyleProp.getFieldOrigin() === FIELD_ORIGIN.SOURCE && dynamicStyleProp.supportsFieldMeta();
+      });
+    if (dynamicStyleProps.length === 0) {
+      return;
+    }
+
+    const requestToken = Symbol(`layer-source-meta:${this.getId()}`);
+    try {
+      const requestMeta = {}; // TODO include time range?
+      startLoading(SOURCE_META_ID_ORIGIN, requestToken, requestMeta);
+      const layerName = await this.getDisplayName();
+      const styleMeta = await this._source.loadStylePropsMeta(layerName, dynamicStyleProps, registerCancelCallback);
+      console.log(styleMeta);
+      stopLoading(SOURCE_META_ID_ORIGIN, requestToken, styleMeta, requestMeta);
+    } catch (error) {
+      if (!(error instanceof DataRequestAbortError)) {
+        onLoadError(SOURCE_META_ID_ORIGIN, requestToken, error.message);
+      }
+    }
+  }
+
   _assignIdsToFeatures(featureCollection) {
 
     //wrt https://github.com/elastic/kibana/issues/39317
@@ -529,6 +567,7 @@ export class VectorLayer extends AbstractLayer {
     }
 
     const sourceResult = await this._syncSource(syncContext);
+    await this._syncSourceStyleMeta(syncContext);
     if (!sourceResult.featureCollection || !sourceResult.featureCollection.features.length) {
       return;
     }