[Lens][TSVB] Navigate from TSVB Gauge to Lens Metric

src/plugins/vis_types/timeseries/public/convert_to_lens/gauge/index.test.ts

@@ -0,0 +1,171 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import { METRIC_TYPES } from '@kbn/data-plugin/public';
+import { stubLogstashDataView } from '@kbn/data-views-plugin/common/data_view.stub';
+import { TSVB_METRIC_TYPES } from '../../../common/enums';
+import { Metric } from '../../../common/types';
+import { convertToLens } from '.';
+import { createPanel, createSeries } from '../lib/__mocks__';
+import { AvgColumn } from '../lib/convert';
+
+const mockGetMetricsColumns = jest.fn();
+const mockGetBucketsColumns = jest.fn();
+const mockGetConfigurationForGauge = jest.fn();
+const mockIsValidMetrics = jest.fn();
+const mockGetDatasourceValue = jest
+  .fn()
+  .mockImplementation(() => Promise.resolve(stubLogstashDataView));
+const mockGetDataSourceInfo = jest.fn();
+const mockGetSeriesAgg = jest.fn();
+
+jest.mock('../../services', () => ({
+  getDataViewsStart: jest.fn(() => mockGetDatasourceValue),
+}));
+
+jest.mock('../lib/series', () => ({
+  getMetricsColumns: jest.fn(() => mockGetMetricsColumns()),
+  getBucketsColumns: jest.fn(() => mockGetBucketsColumns()),
+  getSeriesAgg: jest.fn(() => mockGetSeriesAgg()),
+}));
+
+jest.mock('../lib/configurations/metric', () => ({
+  getConfigurationForGauge: jest.fn(() => mockGetConfigurationForGauge()),
+}));
+
+jest.mock('../lib/metrics', () => {
+  const actual = jest.requireActual('../lib/metrics');
+  return {
+    isValidMetrics: jest.fn(() => mockIsValidMetrics()),
+    getReducedTimeRange: jest.fn().mockReturnValue('10'),
+    SUPPORTED_METRICS: actual.SUPPORTED_METRICS,
+    getFormulaFromMetric: actual.getFormulaFromMetric,
+  };
+});
+
+jest.mock('../lib/datasource', () => ({
+  getDataSourceInfo: jest.fn(() => mockGetDataSourceInfo()),
+}));
+
+describe('convertToLens', () => {
+  const metric = { id: 'some-id', type: METRIC_TYPES.AVG, field: 'test-field' };
+  const model = createPanel({
+    series: [createSeries({ metrics: [metric] })],
+  });
+
+  const metricColumn: AvgColumn = {
+    columnId: 'col-id',
+    dataType: 'number',
+    isSplit: false,
+    isBucketed: false,
+    meta: { metricId: metric.id },
+    operationType: 'average',
+    sourceField: metric.field,
+    params: {},
+    reducedTimeRange: '10m',
+  };
+
+  beforeEach(() => {
+    mockIsValidMetrics.mockReturnValue(true);
+    mockGetDataSourceInfo.mockReturnValue({
+      indexPatternId: 'test-index-pattern',
+      timeField: 'timeField',
+      indexPattern: { id: 'test-index-pattern' },
+    });
+    mockGetMetricsColumns.mockReturnValue([{}]);
+    mockGetBucketsColumns.mockReturnValue([{}]);
+    mockGetConfigurationForGauge.mockReturnValue({});
+    mockGetSeriesAgg.mockReturnValue({ metrics: [] });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return null for invalid metrics', async () => {
+    mockIsValidMetrics.mockReturnValue(null);
+    const result = await convertToLens(model);
+    expect(result).toBeNull();
+    expect(mockIsValidMetrics).toBeCalledTimes(1);
+  });
+
+  test('should return null for invalid or unsupported metrics', async () => {
+    mockGetMetricsColumns.mockReturnValue(null);
+    const result = await convertToLens(model);
+    expect(result).toBeNull();
+    expect(mockGetMetricsColumns).toBeCalledTimes(1);
+  });
+
+  test('should return null for invalid or unsupported buckets', async () => {
+    mockGetBucketsColumns.mockReturnValue(null);
+    const result = await convertToLens(model);
+    expect(result).toBeNull();
+    expect(mockGetBucketsColumns).toBeCalledTimes(1);
+  });
+
+  test('should return null if metric is staticValue', async () => {
+    const result = await convertToLens({
+      ...model,
+      series: [
+        {
+          ...model.series[0],
+          metrics: [...model.series[0].metrics, { type: TSVB_METRIC_TYPES.STATIC } as Metric],
+        },
+      ],
+    });
+    expect(result).toBeNull();
+    expect(mockGetDataSourceInfo).toBeCalledTimes(0);
+  });
+
+  test('should return null if only series agg is specified', async () => {
+    const result = await convertToLens({
+      ...model,
+      series: [
+        {
+          ...model.series[0],
+          metrics: [
+            { type: TSVB_METRIC_TYPES.SERIES_AGG, function: 'min', id: 'some-id' } as Metric,
+          ],
+        },
+      ],
+    });
+    expect(result).toBeNull();
+  });
+
+  test('should return null configuration is not valid', async () => {
+    mockGetMetricsColumns.mockReturnValue([metricColumn]);
+    mockGetSeriesAgg.mockReturnValue({ metrics: [metric] });
+    mockGetConfigurationForGauge.mockReturnValue(null);
+
+    const result = await convertToLens(model);
+    expect(result).toBeNull();
+  });
+
+  test('should return state', async () => {
+    mockGetMetricsColumns.mockReturnValue([metricColumn]);
+    mockGetSeriesAgg.mockReturnValue({ metrics: [metric] });
+    mockGetConfigurationForGauge.mockReturnValue({});
+
+    const result = await convertToLens(
+      createPanel({
+        series: [
+          createSeries({
+            metrics: [{ id: 'some-id', type: METRIC_TYPES.AVG, field: 'test-field' }],
+            hidden: false,
+          }),
+          createSeries({
+            metrics: [{ id: 'some-id', type: METRIC_TYPES.AVG, field: 'test-field' }],
+            hidden: false,
+          }),
+        ],
+      })
+    );
+    expect(result).toBeDefined();
+    expect(result?.type).toBe('lnsMetric');
+  });
+});

src/plugins/vis_types/timeseries/public/convert_to_lens/gauge/index.ts

@@ -0,0 +1,139 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import uuid from 'uuid';
+import { parseTimeShift } from '@kbn/data-plugin/common';
+import {
+  FormulaColumn,
+  getIndexPatternIds,
+  StaticValueColumn,
+} from '@kbn/visualizations-plugin/common/convert_to_lens';
+import { PANEL_TYPES, TSVB_METRIC_TYPES } from '../../../common/enums';
+import { Metric } from '../../../common/types';
+import { getDataViewsStart } from '../../services';
+import { getDataSourceInfo } from '../lib/datasource';
+import { getMetricsColumns, getBucketsColumns } from '../lib/series';
+import { getConfigurationForGauge as getConfiguration } from '../lib/configurations/metric';
+import {
+  getFormulaFromMetric,
+  getReducedTimeRange,
+  isValidMetrics,
+  SUPPORTED_METRICS,
+} from '../lib/metrics';
+import { ConvertTsvbToLensVisualization } from '../types';
+import {
+  Column,
+  createFormulaColumnWithoutMeta,
+  createStaticValueColumn,
+  Layer as ExtendedLayer,
+} from '../lib/convert';
+import { excludeMetaFromLayers, findMetricColumn, getMetricWithCollapseFn } from '../utils';
+
+const getMaxFormula = (metric: Metric, column?: Column) => {
+  const baseFormula = `overall_max`;
+  if (column && column.operationType === 'formula') {
+    return `${baseFormula}(${column.params.formula})`;
+  }
+
+  return `${baseFormula}(${getFormulaFromMetric(SUPPORTED_METRICS[metric.type]!)}(${
+    metric.field ?? ''
+  }))`;
+};
+
+export const convertToLens: ConvertTsvbToLensVisualization = async (model, timeRange) => {
+  const dataViews = getDataViewsStart();
+
+  const series = model.series[0];
+  // not valid time shift
+  if (series.offset_time && parseTimeShift(series.offset_time) === 'invalid') {
+    return null;
+  }
+
+  if (!isValidMetrics(series.metrics, PANEL_TYPES.GAUGE, series.time_range_mode)) {
+    return null;
+  }
+
+  if (series.metrics[series.metrics.length - 1].type === TSVB_METRIC_TYPES.STATIC) {
+    return null;
+  }
+
+  const reducedTimeRange = getReducedTimeRange(model, series, timeRange);
+  const datasourceInfo = await getDataSourceInfo(
+    model.index_pattern,
+    model.time_field,
+    Boolean(series.override_index_pattern),
+    series.series_index_pattern,
+    series.series_time_field,
+    dataViews
+  );
+
+  if (!datasourceInfo) {
+    return null;
+  }
+
+  const { indexPatternId, indexPattern } = datasourceInfo;
+
+  // handle multiple metrics
+  const metricsColumns = getMetricsColumns(series, indexPattern!, model.series.length, {
+    reducedTimeRange,
+  });
+  if (metricsColumns === null) {
+    return null;
+  }
+
+  const bucketsColumns = getBucketsColumns(model, series, metricsColumns, indexPattern!, false);
+
+  if (bucketsColumns === null) {
+    return null;
+  }
+
+  const [bucket] = bucketsColumns;
+
+  const extendedLayer: ExtendedLayer = {
+    indexPatternId,
+    layerId: uuid(),
+    columns: [...metricsColumns, ...(bucket ? [bucket] : [])],
+    columnOrder: [],
+  };
+
+  const primarySeries = model.series[0];
+  const primaryMetricWithCollapseFn = getMetricWithCollapseFn(primarySeries);
+
+  if (!primaryMetricWithCollapseFn || !primaryMetricWithCollapseFn.metric) {
+    return null;
+  }
+
+  const primaryColumn = findMetricColumn(primaryMetricWithCollapseFn.metric, extendedLayer.columns);
+  if (!primaryColumn) {
+    return null;
+  }
+
+  let gaugeMaxColumn: StaticValueColumn | FormulaColumn | null = createFormulaColumnWithoutMeta(
+    getMaxFormula(primaryMetricWithCollapseFn.metric, primaryColumn)
+  );
+  if (model.gauge_max !== undefined && model.gauge_max !== '') {
+    gaugeMaxColumn = createStaticValueColumn(model.gauge_max);
+  }
+
+  const layer = {
+    ...extendedLayer,
+    columns: [...extendedLayer.columns, gaugeMaxColumn],
+  };
+  const configuration = getConfiguration(model, layer, bucket, gaugeMaxColumn ?? undefined);
+  if (!configuration) {
+    return null;
+  }
+
+  const layers = Object.values(excludeMetaFromLayers({ 0: layer }));
+  return {
+    type: 'lnsMetric',
+    layers,
+    configuration,
+    indexPatternIds: getIndexPatternIds(layers),
+  };
+};

src/plugins/vis_types/timeseries/public/convert_to_lens/index.ts

@@ -25,6 +25,10 @@ const getConvertFnByType = (type: PANEL_TYPES) => {
       const { convertToLens } = await import('./metric');
       return convertToLens;
     },
+    [PANEL_TYPES.GAUGE]: async () => {
+      const { convertToLens } = await import('./gauge');
+      return convertToLens;
+    },
   };
 
   return convertionFns[type]?.();