apitech
/
grafana
mirror of https://github.com/grafana/grafana
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Transforms: Labels to fields rewrite that uses merge transform inside it (#27125)

Browse Source 
* testing things

* POC: Simplify labels to fields by using merge transform inside it

* removed old code

* Fixed test ts issues

* Added valueLabel field option

* Updated merge transform tests to not expect a sort

* fixed type

* refactoring to minimize nesting
pull/27187/head
Torkel Ödegaard 5 years ago committed by GitHub
parent d5687cce11
commit ddabf4ade1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 164 additions and 352 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 218
      packages/grafana-data/src/transformations/transformers/labelsToFields.test.ts
  2. 197
      packages/grafana-data/src/transformations/transformers/labelsToFields.ts
  3. 38
      packages/grafana-data/src/transformations/transformers/merge.test.ts
  4. 12
      packages/grafana-data/src/transformations/transformers/merge.ts
  5. 51
      public/app/core/components/TransformersUI/LabelsToFieldsTransformerEditor.tsx

218
packages/grafana-data/src/transformations/transformers/labelsToFields.test.ts
Unescape View File

@ -1,232 +1,104 @@
import { mockTransformationsRegistry } from '../../utils/tests/mockTransformationsRegistry';
import { LabelsToFieldsOptions, labelsToFieldsTransformer } from './labelsToFields';
import { DataTransformerConfig, Field, FieldType } from '../../types';
import { DataTransformerConfig, FieldType, FieldDTO } from '../../types';
import { DataTransformerID } from './ids';
import { toDataFrame } from '../../dataframe';
import { toDataFrame, toDataFrameDTO } from '../../dataframe';
import { transformDataFrame } from '../transformDataFrame';
import { ArrayVector } from '../../vector';
describe('Labels as Columns', () => {
beforeAll(() => {
mockTransformationsRegistry([labelsToFieldsTransformer]);
});
it('data frame with 1 value and 1 label', () => {
it('data frame with two labels', () => {
const cfg: DataTransformerConfig<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
options: {},
};
const oneValueOneLabelA = toDataFrame({
name: 'A',
fields: [
{ name: 'time', type: FieldType.time, values: [1000] },
{ name: 'temp', type: FieldType.number, values: [1], labels: { location: 'inside' } },
],
});
const oneValueOneLabelB = toDataFrame({
name: 'B',
fields: [
{ name: 'time', type: FieldType.time, values: [2000] },
{ name: 'temp', type: FieldType.number, values: [-1], labels: { location: 'outside' } },
],
});
const result = transformDataFrame([cfg], [oneValueOneLabelA, oneValueOneLabelB]);
const expected: Field[] = [
{ name: 'time', type: FieldType.time, values: new ArrayVector([1000, 2000]), config: {} },
{ name: 'location', type: FieldType.string, values: new ArrayVector(['inside', 'outside']), config: {} },
{ name: 'temp', type: FieldType.number, values: new ArrayVector([1, -1]), config: {} },
];
expect(result[0].fields).toEqual(expected);
});
it('data frame with 2 values and 1 label', () => {
const cfg: DataTransformerConfig<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
options: {},
};
const twoValuesOneLabelA = toDataFrame({
name: 'A',
fields: [
{ name: 'time', type: FieldType.time, values: [1000] },
{ name: 'temp', type: FieldType.number, values: [1], labels: { location: 'inside' } },
{ name: 'humidity', type: FieldType.number, values: [10000], labels: { location: 'inside' } },
],
});
const twoValuesOneLabelB = toDataFrame({
name: 'B',
fields: [
{ name: 'time', type: FieldType.time, values: [2000] },
{ name: 'temp', type: FieldType.number, values: [-1], labels: { location: 'outside' } },
{ name: 'humidity', type: FieldType.number, values: [11000], labels: { location: 'outside' } },
],
});
const result = transformDataFrame([cfg], [twoValuesOneLabelA, twoValuesOneLabelB]);
const expected: Field[] = [
{ name: 'time', type: FieldType.time, values: new ArrayVector([1000, 2000]), config: {} },
{ name: 'location', type: FieldType.string, values: new ArrayVector(['inside', 'outside']), config: {} },
{ name: 'temp', type: FieldType.number, values: new ArrayVector([1, -1]), config: {} },
{ name: 'humidity', type: FieldType.number, values: new ArrayVector([10000, 11000]), config: {} },
];
expect(result[0].fields).toEqual(expected);
});
it('data frame with 1 value and 2 labels', () => {
const cfg: DataTransformerConfig<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
options: {},
};
const oneValueTwoLabelsA = toDataFrame({
const source = toDataFrame({
name: 'A',
fields: [
{ name: 'time', type: FieldType.time, values: [1000] },
{ name: 'temp', type: FieldType.number, values: [1], labels: { location: 'inside', area: 'living room' } },
],
});
const oneValueTwoLabelsB = toDataFrame({
name: 'B',
fields: [
{ name: 'time', type: FieldType.time, values: [2000] },
{ name: 'temp', type: FieldType.number, values: [-1], labels: { location: 'outside', area: 'backyard' } },
{ name: 'time', type: FieldType.time, values: [1000, 2000] },
{ name: 'Value', type: FieldType.number, values: [1, 2], labels: { location: 'inside', feelsLike: 'ok' } },
],
});
const result = transformDataFrame([cfg], [oneValueTwoLabelsA, oneValueTwoLabelsB]);
const expected: Field[] = [
{ name: 'time', type: FieldType.time, values: new ArrayVector([1000, 2000]), config: {} },
{ name: 'location', type: FieldType.string, values: new ArrayVector(['inside', 'outside']), config: {} },
{ name: 'area', type: FieldType.string, values: new ArrayVector(['living room', 'backyard']), config: {} },
{ name: 'temp', type: FieldType.number, values: new ArrayVector([1, -1]), config: {} },
const result = toDataFrameDTO(transformDataFrame([cfg], [source])[0]);
const expected: FieldDTO[] = [
{ name: 'time', type: FieldType.time, values: [1000, 2000], config: {} },
{
name: 'location',
type: FieldType.string,
values: ['inside', 'inside'],
config: {},
},
{ name: 'feelsLike', type: FieldType.string, values: ['ok', 'ok'], config: {} },
{ name: 'Value', type: FieldType.number, values: [1, 2], config: {} },
];
expect(result[0].fields).toEqual(expected);
expect(result.fields).toEqual(expected);
});
it('data frame with 2 values and 2 labels', () => {
it('data frame with two labels and valueLabel option', () => {
const cfg: DataTransformerConfig<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
options: {},
options: { valueLabel: 'name' },
};
const twoValuesTwoLabelsA = toDataFrame({
const source = toDataFrame({
name: 'A',
fields: [
{ name: 'time', type: FieldType.time, values: [1000] },
{ name: 'temp', type: FieldType.number, values: [1], labels: { location: 'inside', area: 'living room' } },
{
name: 'humidity',
type: FieldType.number,
values: [10000],
labels: { location: 'inside', area: 'living room' },
},
],
});
const twoValuesTwoLabelsB = toDataFrame({
name: 'B',
fields: [
{ name: 'time', type: FieldType.time, values: [2000] },
{ name: 'temp', type: FieldType.number, values: [-1], labels: { location: 'outside', area: 'backyard' } },
{
name: 'humidity',
type: FieldType.number,
values: [11000],
labels: { location: 'outside', area: 'backyard' },
},
{ name: 'time', type: FieldType.time, values: [1000, 2000] },
{ name: 'Value', type: FieldType.number, values: [1, 2], labels: { location: 'inside', name: 'Request' } },
],
});
const result = transformDataFrame([cfg], [twoValuesTwoLabelsA, twoValuesTwoLabelsB]);
const expected: Field[] = [
{ name: 'time', type: FieldType.time, values: new ArrayVector([1000, 2000]), config: {} },
{ name: 'location', type: FieldType.string, values: new ArrayVector(['inside', 'outside']), config: {} },
{ name: 'area', type: FieldType.string, values: new ArrayVector(['living room', 'backyard']), config: {} },
{ name: 'temp', type: FieldType.number, values: new ArrayVector([1, -1]), config: {} },
{ name: 'humidity', type: FieldType.number, values: new ArrayVector([10000, 11000]), config: {} },
const result = toDataFrameDTO(transformDataFrame([cfg], [source])[0]);
const expected: FieldDTO[] = [
{ name: 'time', type: FieldType.time, values: [1000, 2000], config: {} },
{
name: 'location',
type: FieldType.string,
values: ['inside', 'inside'],
config: {},
},
{ name: 'Request', type: FieldType.number, values: [1, 2], config: {} },
];
expect(result[0].fields).toEqual(expected);
expect(result.fields).toEqual(expected);
});
it('data frames with different labels', () => {
it('two data frames with 1 value and 1 label', () => {
const cfg: DataTransformerConfig<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
options: {},
};
const oneValueDifferentLabelsA = toDataFrame({
const oneValueOneLabelA = toDataFrame({
name: 'A',
fields: [
{ name: 'time', type: FieldType.time, values: [1000] },
{ name: 'temp', type: FieldType.number, values: [1], labels: { location: 'inside', feelsLike: 'ok' } },
{ name: 'temp', type: FieldType.number, values: [1], labels: { location: 'inside' } },
],
});
const oneValueDifferentLabelsB = toDataFrame({
const oneValueOneLabelB = toDataFrame({
name: 'B',
fields: [
{ name: 'time', type: FieldType.time, values: [2000] },
{ name: 'temp', type: FieldType.number, values: [-1], labels: { location: 'outside', sky: 'cloudy' } },
],
});
const result = transformDataFrame([cfg], [oneValueDifferentLabelsA, oneValueDifferentLabelsB]);
const expected: Field[] = [
{ name: 'time', type: FieldType.time, values: new ArrayVector([1000, 2000]), config: {} },
{ name: 'location', type: FieldType.string, values: new ArrayVector(['inside', 'outside']), config: {} },
{ name: 'feelsLike', type: FieldType.string, values: new ArrayVector(['ok', null]), config: {} },
{ name: 'sky', type: FieldType.string, values: new ArrayVector([null, 'cloudy']), config: {} },
{ name: 'temp', type: FieldType.number, values: new ArrayVector([1, -1]), config: {} },
];
expect(result[0].fields).toEqual(expected);
});
it('data frames with same timestamp and different labels', () => {
const cfg: DataTransformerConfig<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
options: {},
};
const oneValueDifferentLabelsA = toDataFrame({
name: 'A',
fields: [
{ name: 'time', type: FieldType.time, values: [1000, 2000] },
{ name: 'temp', type: FieldType.number, values: [1, 2], labels: { location: 'inside', feelsLike: 'ok' } },
{ name: 'temp', type: FieldType.number, values: [-1], labels: { location: 'outside' } },
],
});
const oneValueDifferentLabelsB = toDataFrame({
name: 'B',
fields: [
{ name: 'time', type: FieldType.time, values: [1000, 2000] },
{ name: 'temp', type: FieldType.number, values: [-1, -2], labels: { location: 'outside', sky: 'cloudy' } },
],
});
const result = toDataFrameDTO(transformDataFrame([cfg], [oneValueOneLabelA, oneValueOneLabelB])[0]);
const result = transformDataFrame([cfg], [oneValueDifferentLabelsA, oneValueDifferentLabelsB]);
const expected: Field[] = [
{ name: 'time', type: FieldType.time, values: new ArrayVector([1000, 1000, 2000, 2000]), config: {} },
{
name: 'location',
type: FieldType.string,
values: new ArrayVector(['inside', 'outside', 'inside', 'outside']),
config: {},
},
{ name: 'feelsLike', type: FieldType.string, values: new ArrayVector(['ok', null, 'ok', null]), config: {} },
{ name: 'sky', type: FieldType.string, values: new ArrayVector([null, 'cloudy', null, 'cloudy']), config: {} },
{ name: 'temp', type: FieldType.number, values: new ArrayVector([1, -1, 2, -2]), config: {} },
const expected: FieldDTO[] = [
{ name: 'time', type: FieldType.time, values: [1000, 2000], config: {} },
{ name: 'location', type: FieldType.string, values: ['inside', 'outside'], config: {} },
{ name: 'temp', type: FieldType.number, values: [1, -1], config: {} },
];
expect(result[0].fields).toEqual(expected);
expect(result.fields).toEqual(expected);
});
});

197
packages/grafana-data/src/transformations/transformers/labelsToFields.ts
Unescape View File

@ -1,173 +1,68 @@
import { DataFrame, DataTransformerInfo, FieldType, Field } from '../../types';
import { DataTransformerID } from './ids';
import { ArrayVector } from '../../vector';
import { filterFieldsTransformer } from './filter';
import { FieldMatcherID } from '..';
import { MutableField } from '../../dataframe';
import { mergeTransformer } from './merge';
export interface LabelsToFieldsOptions {}
type MapItem = { type: FieldType; values: Record<string, any>; isValue: boolean };
type SeriesMapItem = Record<string, MapItem>;
type Map = Record<string, SeriesMapItem>;
export interface LabelsToFieldsOptions {
/*
* If set this will use this label's value as the value field name.
*/
valueLabel?: string;
}
export const labelsToFieldsTransformer: DataTransformerInfo<LabelsToFieldsOptions> = {
id: DataTransformerID.labelsToFields,
name: 'Labels to fields',
description: 'Groups series by time and return labels as columns',
description: 'Extract time series labels to fields (columns)',
defaultOptions: {},
transformer: options => (data: DataFrame[]) => {
const framesWithTimeField = filterFieldsTransformer.transformer({ include: { id: FieldMatcherID.time } })(data);
if (!framesWithTimeField.length || !framesWithTimeField[0].fields.length) {
return data;
}
// get frames with only value fields
const framesWithoutTimeField = getFramesWithOnlyValueFields(data);
if (!framesWithoutTimeField.length || !framesWithoutTimeField[0].fields.length) {
return data;
}
const columnsMap = createColumnsMap(framesWithTimeField, framesWithoutTimeField);
const fields = createFields(columnsMap);
const values: Record<string, any[]> = {};
const timeColumnItem = columnsMap[fields[0].name];
const seriesIndexStrings = Object.keys(timeColumnItem);
for (const seriesIndexString of seriesIndexStrings) {
const seriesItem = timeColumnItem[seriesIndexString];
const timeValueStrings = Object.keys(seriesItem.values);
const result: DataFrame[] = [];
for (const timeValueString of timeValueStrings) {
if (!values[timeValueString]) {
values[timeValueString] = [];
}
let row = new Array(fields.length);
for (let index = 0; index < fields.length; index++) {
const field = fields[index];
const valueItem = columnsMap[field.name][seriesIndexString];
const value = valueItem ? valueItem.values[timeValueString] ?? null : null;
row[index] = value;
}
values[timeValueString].push(row);
}
}
for (const frame of data) {
const newFields: Field[] = [];
const timestamps = Object.values(values);
for (const timestamp of timestamps) {
for (const row of timestamp) {
for (let fieldIndex = 0; fieldIndex < fields.length; fieldIndex++) {
fields[fieldIndex].values.add(row[fieldIndex]);
for (const field of frame.fields) {
if (!field.labels) {
newFields.push(field);
continue;
}
}
}
return [
{
fields,
length: fields[0].values.length,
},
];
},
};
function getFramesWithOnlyValueFields(data: DataFrame[]): DataFrame[] {
const processed: DataFrame[] = [];
for (const series of data) {
const fields: Field[] = [];
for (let i = 0; i < series.fields.length; i++) {
const field = series.fields[i];
if (field.type !== FieldType.number) {
continue;
}
fields.push(field);
}
if (!fields.length) {
continue;
}
let name = field.name;
const copy = {
...series, // all the other properties
fields, // but a different set of fields
};
processed.push(copy);
}
return processed;
}
function addOrAppendMapItem(args: { map: Map; series: number; column: string; type: FieldType; isValue?: boolean }) {
const { map, column, type, series, isValue = false } = args;
// we're using the fact that the series (number) will automatically become a string prop on the object
const seriesMapItem: SeriesMapItem = { [series]: { type, values: {}, isValue } };
if (!map[column]) {
map[column] = seriesMapItem;
}
if (!map[column][series]) {
map[column] = { ...map[column], ...seriesMapItem };
}
}
// this is a naive implementation that does the job, not optimized for performance or speed
function createColumnsMap(framesWithTimeField: DataFrame[], framesWithoutTimeField: DataFrame[]) {
const map: Map = {};
for (let frameIndex = 0; frameIndex < framesWithTimeField.length; frameIndex++) {
const timeFrame = framesWithTimeField[frameIndex];
const otherFrame = framesWithoutTimeField[frameIndex];
const timeField = timeFrame.fields[0];
addOrAppendMapItem({ map, column: timeField.name, series: frameIndex, type: timeField.type });
for (let valueIndex = 0; valueIndex < timeFrame.length; valueIndex++) {
const timeFieldValue = timeField.values.get(valueIndex);
map[timeField.name][frameIndex].values[timeFieldValue] = timeFieldValue;
for (const field of otherFrame.fields) {
if (field.labels) {
const labels = Object.keys(field.labels);
for (const label of labels) {
addOrAppendMapItem({ map, column: label, series: frameIndex, type: FieldType.string });
map[label][frameIndex].values[timeFieldValue] = field.labels[label];
for (const labelName of Object.keys(field.labels)) {
// if we should use this label as the value field name store it and skip adding this as a seperate field
if (options.valueLabel === labelName) {
name = field.labels[labelName];
continue;
}
}
const otherFieldValue = field.values.get(valueIndex);
addOrAppendMapItem({ map, column: field.name, series: frameIndex, type: field.type, isValue: true });
const values = new Array(frame.length).fill(field.labels[labelName]);
newFields.push({
name: labelName,
type: FieldType.string,
values: new ArrayVector(values),
config: {},
});
}
map[field.name][frameIndex].values[timeFieldValue] = otherFieldValue;
// add the value field but clear out any labels or displayName
newFields.push({
...field,
name,
config: {
...field.config,
displayName: undefined,
},
labels: undefined,
});
}
}
}
return map;
}
function createFields(columnsMap: Map): MutableField[] {
const columns = Object.keys(columnsMap);
const fields: MutableField[] = [];
const valueColumns: string[] = [];
for (const column of columns) {
const columnItem = Object.values<MapItem>(columnsMap[column])[0];
if (columnItem.isValue) {
valueColumns.push(column);
continue;
result.push({
fields: newFields,
length: frame.length,
});
}
fields.push({ type: columnItem.type, values: new ArrayVector(), name: column, config: {} });
}
for (const column of valueColumns) {
const columnItem = Object.values<MapItem>(columnsMap[column])[0];
fields.push({ type: columnItem.type, values: new ArrayVector(), name: column, config: {} });
}
return fields;
}
return mergeTransformer.transformer({})(result);
},
};

38
packages/grafana-data/src/transformations/transformers/merge.test.ts
Unescape View File

@ -35,8 +35,8 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [seriesA, seriesB]);
const expected: Field[] = [
createField('Time', FieldType.time, [2000, 1000]),
createField('Temp', FieldType.number, [-1, 1]),
createField('Time', FieldType.time, [1000, 2000]),
createField('Temp', FieldType.number, [1, -1]),
];
expect(unwrap(result[0].fields)).toEqual(expected);
@ -66,8 +66,8 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [seriesA, seriesB]);
const expected: Field[] = [
createField('Time', FieldType.time, [200, 150, 126, 125, 100, 100]),
createField('Temp', FieldType.number, [5, 4, 3, 2, 1, -1]),
createField('Time', FieldType.time, [100, 150, 200, 100, 125, 126]),
createField('Temp', FieldType.number, [1, 4, 5, -1, 2, 3]),
];
expect(unwrap(result[0].fields)).toEqual(expected);
@ -105,8 +105,8 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [seriesA, seriesB, seriesC]);
const expected: Field[] = [
createField('Time', FieldType.time, [2000, 1000, 500]),
createField('Temp', FieldType.number, [-1, 1, 2]),
createField('Time', FieldType.time, [1000, 2000, 500]),
createField('Temp', FieldType.number, [1, -1, 2]),
];
expect(unwrap(result[0].fields)).toEqual(expected);
@ -188,9 +188,9 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [tableA, seriesB, tableC]);
const expected: Field[] = [
createField('Time', FieldType.time, ['2019-11-01T11:10:23Z', '2019-10-01T11:10:23Z', '2019-09-01T11:10:23Z']),
createField('Temp', FieldType.number, [2, 1, -1]),
createField('Humidity', FieldType.number, [5, 10, null]),
createField('Time', FieldType.time, ['2019-10-01T11:10:23Z', '2019-09-01T11:10:23Z', '2019-11-01T11:10:23Z']),
createField('Temp', FieldType.number, [1, -1, 2]),
createField('Humidity', FieldType.number, [10, null, 5]),
];
expect(unwrap(result[0].fields)).toEqual(expected);
@ -232,10 +232,10 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [tableA, tableB, tableC]);
const expected: Field[] = [
createField('Time', FieldType.time, [200, 150, 149, 126, 125, 124, 100, 100, 100]),
createField('Temp', FieldType.number, [5, 4, 5, 3, 2, 4, 1, -1, 1]),
createField('Humidity', FieldType.number, [55, 14, 30, null, null, 25, 10, null, 22]),
createField('Enabled', FieldType.boolean, [null, null, null, true, false, null, null, true, null]),
createField('Time', FieldType.time, [100, 150, 200, 100, 125, 126, 100, 124, 149]),
createField('Temp', FieldType.number, [1, 4, 5, -1, 2, 3, 1, 4, 5]),
createField('Humidity', FieldType.number, [10, 14, 55, null, null, null, 22, 25, 30]),
createField('Enabled', FieldType.boolean, [null, null, null, true, false, true, null, null, null]),
];
expect(unwrap(result[0].fields)).toEqual(expected);
@ -265,8 +265,8 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [serieA, serieB]);
const expected: Field[] = [
createField('Time', FieldType.time, [200, 150, 126, 125, 100, 100]),
createField('Temp', FieldType.number, [5, 4, 3, 2, 1, -1]),
createField('Time', FieldType.time, [100, 150, 200, 100, 125, 126]),
createField('Temp', FieldType.number, [1, 4, 5, -1, 2, 3]),
];
const fields = unwrap(result[0].fields);
@ -299,8 +299,8 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [serieA, serieB]);
const expected: Field[] = [
createField('Time', FieldType.time, [200, 150, 126, 125, 100, 100]),
createField('Temp', FieldType.number, [5, 4, 3, 2, 1, -1], { units: 'celsius' }),
createField('Time', FieldType.time, [100, 150, 200, 100, 125, 126]),
createField('Temp', FieldType.number, [1, 4, 5, -1, 2, 3], { units: 'celsius' }),
];
const fields = unwrap(result[0].fields);
@ -333,8 +333,8 @@ describe('Merge multipe to single', () => {
const result = transformDataFrame([cfg], [serieA, serieB]);
const expected: Field[] = [
createField('Time', FieldType.time, [200, 150, 126, 125, 100, 100]),
createField('Temp', FieldType.number, [5, 4, 3, 2, 1, -1]),
createField('Time', FieldType.time, [100, 150, 200, 100, 125, 126]),
createField('Temp', FieldType.number, [1, 4, 5, -1, 2, 3]),
];
const fields = unwrap(result[0].fields);

12
packages/grafana-data/src/transformations/transformers/merge.ts
Unescape View File

@ -1,9 +1,9 @@
import { DataTransformerID } from './ids';
import { DataTransformerInfo } from '../../types/transformations';
import { DataFrame, Field, FieldType } from '../../types/dataFrame';
import { DataFrame, Field } from '../../types/dataFrame';
import { omit } from 'lodash';
import { ArrayVector } from '../../vector/ArrayVector';
import { MutableDataFrame, sortDataFrame } from '../../dataframe';
import { MutableDataFrame } from '../../dataframe';
type MergeDetailsKeyFactory = (existing: Record<string, any>, value: Record<string, any>) => string;
@ -68,10 +68,10 @@ export const mergeTransformer: DataTransformerInfo<MergeTransformerOptions> = {
}
}
const timeIndex = dataFrame.fields.findIndex(field => field.type === FieldType.time);
if (typeof timeIndex === 'number') {
return [sortDataFrame(dataFrame, timeIndex, true)];
}
// const timeIndex = dataFrame.fields.findIndex(field => field.type === FieldType.time);
// if (typeof timeIndex === 'number') {
// return [sortDataFrame(dataFrame, timeIndex, true)];
// }
return [dataFrame];
};
},

51
public/app/core/components/TransformersUI/LabelsToFieldsTransformerEditor.tsx
Unescape View File

@ -1,5 +1,12 @@
import React from 'react';
import { DataTransformerID, standardTransformers, TransformerRegistyItem, TransformerUIProps } from '@grafana/data';
import {
DataTransformerID,
standardTransformers,
TransformerRegistyItem,
TransformerUIProps,
SelectableValue,
} from '@grafana/data';
import { Select } from '@grafana/ui';
import { LabelsToFieldsOptions } from '@grafana/data/src/transformations/transformers/labelsToFields';
@ -8,7 +15,45 @@ export const LabelsAsFieldsTransformerEditor: React.FC<TransformerUIProps<Labels
options,
onChange,
}) => {
return null;
let labelNames: Array<SelectableValue<string>> = [];
let uniqueLabels: Record<string, boolean> = {};
for (const frame of input) {
for (const field of frame.fields) {
if (!field.labels) {
continue;
}
for (const labelName of Object.keys(field.labels)) {
if (!uniqueLabels[labelName]) {
labelNames.push({ value: labelName, label: labelName });
uniqueLabels[labelName] = true;
}
}
}
}
const onValueLabelChange = (value: SelectableValue<string> | null) => {
onChange({ valueLabel: value?.value });
};
return (
<div className="gf-form-inline">
<div className="gf-form">
<div className="gf-form-label width-8">Value field name</div>
<Select
isClearable={true}
allowCustomValue={false}
placeholder="(Optional) Select label"
options={labelNames}
className="min-width-18 gf-form-spacing"
value={options?.valueLabel}
onChange={onValueLabelChange}
menuPlacement="bottom"
/>
</div>
</div>
);
};
export const labelsToFieldsTransformerRegistryItem: TransformerRegistyItem<LabelsToFieldsOptions> = {
@ -16,6 +61,6 @@ export const labelsToFieldsTransformerRegistryItem: TransformerRegistyItem<Label
editor: LabelsAsFieldsTransformerEditor,
transformation: standardTransformers.labelsToFieldsTransformer,
name: 'Labels to fields',
description: `Groups series by time and return labels or tags as fields.
description: `Groups series by time and return labels or tags as fields.
Useful for showing time series with labels in a table where each label key becomes a seperate column`,
};

Write Preview
Loading…
Cancel
Save