[Lens] Bind all time fields to the time picker

src/plugins/data/public/query/timefilter/get_time.ts

@@ -32,6 +32,44 @@ export function calculateBounds(timeRange: TimeRange, options: CalculateBoundsOp
   };
 }
 
+function createTimeRangeFilter(
+  indexPattern: IIndexPattern,
+  timeRange: TimeRange,
+  field: IFieldType,
+  forceNow?: Date
+) {
+  const bounds = calculateBounds(timeRange, { forceNow });
+  if (!bounds) {
+    return;
+  }
+  return buildRangeFilter(
+    field,
+    {
+      ...(bounds.min && { gte: bounds.min.toISOString() }),
+      ...(bounds.max && { lte: bounds.max.toISOString() }),
+      format: 'strict_date_optional_time',
+    },
+    indexPattern
+  );
+}
+
+export function getTimeForField(
+  indexPattern: IIndexPattern | undefined,
+  timeRange: TimeRange,
+  fieldName: string
+) {
+  if (!indexPattern) {
+    return;
+  }
+
+  const field = indexPattern.fields.find(f => f.name === fieldName);
+  if (!field) {
+    return;
+  }
+
+  return createTimeRangeFilter(indexPattern, timeRange, field);
+}
+
 export function getTime(
   indexPattern: IIndexPattern | undefined,
   timeRange: TimeRange,
@@ -50,17 +88,5 @@ export function getTime(
     return;
   }
 
-  const bounds = calculateBounds(timeRange, { forceNow });
-  if (!bounds) {
-    return;
-  }
-  return buildRangeFilter(
-    timefield,
-    {
-      ...(bounds.min && { gte: bounds.min.toISOString() }),
-      ...(bounds.max && { lte: bounds.max.toISOString() }),
-      format: 'strict_date_optional_time',
-    },
-    indexPattern
-  );
+  return createTimeRangeFilter(indexPattern, timeRange, timefield, forceNow);
 }

src/plugins/data/public/search/aggs/buckets/date_histogram.ts

@@ -45,7 +45,7 @@ const updateTimeBuckets = (
   customBuckets?: IBucketDateHistogramAggConfig['buckets']
 ) => {
   const bounds =
-    agg.params.timeRange && agg.fieldIsTimeField()
+    agg.params.timeRange && (agg.fieldIsTimeField() || agg.params.interval === 'auto')
       ? timefilter.calculateBounds(agg.params.timeRange)
       : undefined;
   const buckets = customBuckets || agg.buckets;

src/plugins/data/public/search/expressions/esaggs.ts

@@ -32,16 +32,26 @@ import { Adapters } from '../../../../../plugins/inspector/public';
 import { IAggConfigs } from '../aggs';
 import { ISearchSource, SearchSource } from '../search_source';
 import { tabifyAggResponse } from '../tabify';
-import { Filter, Query, serializeFieldFormat, TimeRange } from '../../../common';
-import { FilterManager, getTime } from '../../query';
+import {
+  Filter,
+  Query,
+  serializeFieldFormat,
+  TimeRange,
+  IIndexPattern,
+  RangeFilter,
+} from '../../../common';
+import { FilterManager } from '../../query';
 import { getSearchService, getQueryService, getIndexPatterns } from '../../services';
 import { buildTabularInspectorData } from './build_tabular_inspector_data';
 import { getRequestInspectorStats, getResponseInspectorStats, serializeAggConfig } from './utils';
+import { calculateBounds, getTimeForField } from '../../query/timefilter/get_time';
 
 export interface RequestHandlerParams {
   searchSource: ISearchSource;
   aggs: IAggConfigs;
   timeRange?: TimeRange;
+  timeFields?: string[];
+  indexPattern?: IIndexPattern;
   query?: Query;
   filters?: Filter[];
   forceFetch: boolean;
@@ -65,12 +75,15 @@ interface Arguments {
   partialRows: boolean;
   includeFormatHints: boolean;
   aggConfigs: string;
+  timeField?: string[];
 }
 
 const handleCourierRequest = async ({
   searchSource,
   aggs,
   timeRange,
+  timeFields,
+  indexPattern,
   query,
   filters,
   forceFetch,
@@ -111,9 +124,22 @@ const handleCourierRequest = async ({
     return aggs.onSearchRequestStart(paramSearchSource, options);
   });
 
-  if (timeRange) {
+  // If timeFields have been specified, use the specified ones, otherwise use primary time field of index
+  // pattern if it's available.
+  const allTimeFields =
+    timeFields && timeFields.length > 0
+      ? timeFields
+      : [
+          indexPattern?.fields.find(field => field.name === indexPattern.timeFieldName)?.name,
+        ].filter((fieldName): fieldName is string => Boolean(fieldName));
+
+  // If a timeRange has been specified and we had at least one timeField available, create range
+  // filters for that those time fields
+  if (timeRange && allTimeFields.length > 0) {
     timeFilterSearchSource.setField('filter', () => {
-      return getTime(searchSource.getField('index'), timeRange);
+      return allTimeFields
+        .map(fieldName => getTimeForField(indexPattern, timeRange, fieldName))
+        .filter((rangeFilter): rangeFilter is RangeFilter => Boolean(rangeFilter));
     });
   }
 
@@ -181,11 +207,13 @@ const handleCourierRequest = async ({
 
   (searchSource as any).finalResponse = resp;
 
-  const parsedTimeRange = timeRange ? getTime(aggs.indexPattern, timeRange) : null;
+  const parsedTimeRange = timeRange ? calculateBounds(timeRange) : null;
   const tabifyParams = {
     metricsAtAllLevels,
     partialRows,
-    timeRange: parsedTimeRange ? parsedTimeRange.range : undefined,
+    timeRange: parsedTimeRange
+      ? { from: parsedTimeRange.min, to: parsedTimeRange.max, timeFields: allTimeFields }
+      : undefined,
   };
 
   const tabifyCacheHash = calculateObjectHash({ tabifyAggs: aggs, ...tabifyParams });
@@ -242,6 +270,11 @@ export const esaggs = (): ExpressionFunctionDefinition<typeof name, Input, Argum
       default: '""',
       help: '',
     },
+    timeField: {
+      types: ['string'],
+      help: '',
+      multi: true,
+    },
   },
   async fn(input, args, { inspectorAdapters, abortSignal }) {
     const indexPatterns = getIndexPatterns();
@@ -260,9 +293,11 @@ export const esaggs = (): ExpressionFunctionDefinition<typeof name, Input, Argum
     const response = await handleCourierRequest({
       searchSource,
       aggs,
+      indexPattern,
       timeRange: get(input, 'timeRange', undefined),
       query: get(input, 'query', undefined),
       filters: get(input, 'filters', undefined),
+      timeFields: args.timeField,
       forceFetch: true,
       metricsAtAllLevels: args.metricsAtAllLevels,
       partialRows: args.partialRows,

src/plugins/data/public/search/tabify/buckets.test.ts

@@ -19,6 +19,11 @@
 
 import { TabifyBuckets } from './buckets';
 import { AggGroupNames } from '../aggs';
+import moment from 'moment';
+
+interface Bucket {
+  key: number | string;
+}
 
 describe('Buckets wrapper', () => {
   const check = (aggResp: any, count: number, keys: string[]) => {
@@ -187,9 +192,9 @@ describe('Buckets wrapper', () => {
         },
       };
       const timeRange = {
-        gte: 150,
-        lte: 350,
-        name: 'date',
+        from: moment(150),
+        to: moment(350),
+        timeFields: ['date'],
       };
       const buckets = new TabifyBuckets(aggResp, aggParams, timeRange);
 
@@ -204,9 +209,9 @@ describe('Buckets wrapper', () => {
         },
       };
       const timeRange = {
-        gte: 150,
-        lte: 350,
-        name: 'date',
+        from: moment(150),
+        to: moment(350),
+        timeFields: ['date'],
       };
       const buckets = new TabifyBuckets(aggResp, aggParams, timeRange);
 
@@ -221,9 +226,9 @@ describe('Buckets wrapper', () => {
         },
       };
       const timeRange = {
-        gte: 100,
-        lte: 400,
-        name: 'date',
+        from: moment(100),
+        to: moment(400),
+        timeFields: ['date'],
       };
       const buckets = new TabifyBuckets(aggResp, aggParams, timeRange);
 
@@ -238,13 +243,47 @@ describe('Buckets wrapper', () => {
         },
       };
       const timeRange = {
-        gte: 150,
-        lte: 350,
-        name: 'date',
+        from: moment(150),
+        to: moment(350),
+        timeFields: ['date'],
       };
       const buckets = new TabifyBuckets(aggResp, aggParams, timeRange);
 
       expect(buckets).toHaveLength(4);
     });
+
+    test('does drop bucket when multiple time fields specified', () => {
+      const aggParams = {
+        drop_partials: true,
+        field: {
+          name: 'date',
+        },
+      };
+      const timeRange = {
+        from: moment(100),
+        to: moment(350),
+        timeFields: ['date', 'other_datefield'],
+      };
+      const buckets = new TabifyBuckets(aggResp, aggParams, timeRange);
+
+      expect(buckets.buckets.map((b: Bucket) => b.key)).toEqual([100, 200]);
+    });
+
+    test('does not drop bucket when no timeFields have been specified', () => {
+      const aggParams = {
+        drop_partials: true,
+        field: {
+          name: 'date',
+        },
+      };
+      const timeRange = {
+        from: moment(100),
+        to: moment(350),
+        timeFields: [],
+      };
+      const buckets = new TabifyBuckets(aggResp, aggParams, timeRange);
+
+      expect(buckets.buckets.map((b: Bucket) => b.key)).toEqual([0, 100, 200, 300]);
+    });
   });
 });

src/plugins/data/public/search/tabify/buckets.ts

@@ -20,7 +20,7 @@
 import { get, isPlainObject, keys, findKey } from 'lodash';
 import moment from 'moment';
 import { IAggConfig } from '../aggs';
-import { AggResponseBucket, TabbedRangeFilterParams } from './types';
+import { AggResponseBucket, TabbedRangeFilterParams, TimeRangeInformation } from './types';
 
 type AggParams = IAggConfig['params'] & {
   drop_partials: boolean;
@@ -36,7 +36,7 @@ export class TabifyBuckets {
   buckets: any;
   _keys: any[] = [];
 
-  constructor(aggResp: any, aggParams?: AggParams, timeRange?: TabbedRangeFilterParams) {
+  constructor(aggResp: any, aggParams?: AggParams, timeRange?: TimeRangeInformation) {
     if (aggResp && aggResp.buckets) {
       this.buckets = aggResp.buckets;
     } else if (aggResp) {
@@ -107,23 +107,23 @@ export class TabifyBuckets {
 
   // dropPartials should only be called if the aggParam setting is enabled,
   // and the agg field is the same as the Time Range.
-  private dropPartials(params: AggParams, timeRange?: TabbedRangeFilterParams) {
+  private dropPartials(params: AggParams, timeRange?: TimeRangeInformation) {
     if (
       !timeRange ||
       this.buckets.length <= 1 ||
       this.objectMode ||
-      params.field.name !== timeRange.name
+      !timeRange.timeFields.includes(params.field.name)
     ) {
       return;
     }
 
     const interval = this.buckets[1].key - this.buckets[0].key;
 
     this.buckets = this.buckets.filter((bucket: AggResponseBucket) => {
-      if (moment(bucket.key).isBefore(timeRange.gte)) {
+      if (moment(bucket.key).isBefore(timeRange.from)) {
         return false;
       }
-      if (moment(bucket.key + interval).isAfter(timeRange.lte)) {
+      if (moment(bucket.key + interval).isAfter(timeRange.to)) {
         return false;
       }
       return true;

src/plugins/data/public/search/tabify/tabify.ts

@@ -20,7 +20,7 @@
 import { get } from 'lodash';
 import { TabbedAggResponseWriter } from './response_writer';
 import { TabifyBuckets } from './buckets';
-import { TabbedResponseWriterOptions, TabbedRangeFilterParams } from './types';
+import { TabbedResponseWriterOptions } from './types';
 import { AggResponseBucket } from './types';
 import { AggGroupNames, IAggConfigs } from '../aggs';
 
@@ -54,7 +54,7 @@ export function tabifyAggResponse(
       switch (agg.type.type) {
         case AggGroupNames.Buckets:
           const aggBucket = get(bucket, agg.id);
-          const tabifyBuckets = new TabifyBuckets(aggBucket, agg.params, timeRange);
+          const tabifyBuckets = new TabifyBuckets(aggBucket, agg.params, respOpts?.timeRange);
 
           if (tabifyBuckets.length) {
             tabifyBuckets.forEach((subBucket, tabifyBucketKey) => {
@@ -153,20 +153,6 @@ export function tabifyAggResponse(
     doc_count: esResponse.hits.total,
   };
 
-  let timeRange: TabbedRangeFilterParams | undefined;
-
-  // Extract the time range object if provided
-  if (respOpts && respOpts.timeRange) {
-    const [timeRangeKey] = Object.keys(respOpts.timeRange);
-
-    if (timeRangeKey) {
-      timeRange = {
-        name: timeRangeKey,
-        ...respOpts.timeRange[timeRangeKey],
-      };
-    }
-  }
-
   collectBucket(aggConfigs, write, topLevelBucket, '', 1);
 
   return write.response();

src/plugins/data/public/search/tabify/types.ts

@@ -17,6 +17,7 @@
  * under the License.
  */
 
+import { Moment } from 'moment';
 import { RangeFilterParams } from '../../../common';
 import { IAggConfig } from '../aggs';
 
@@ -25,11 +26,18 @@ export interface TabbedRangeFilterParams extends RangeFilterParams {
   name: string;
 }
 
+/** @internal */
+export interface TimeRangeInformation {
+  from?: Moment;
+  to?: Moment;
+  timeFields: string[];
+}
+
 /** @internal **/
 export interface TabbedResponseWriterOptions {
   metricsAtAllLevels: boolean;
   partialRows: boolean;
-  timeRange?: { [key: string]: RangeFilterParams };
+  timeRange?: TimeRangeInformation;
 }
 
 /** @internal */