IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-25 18:55:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: rename statsCalculator to fieldReducer (#16867)

Browse Source
This commit is contained in:
Ryan McKinley
2019-05-03 13:16:33 -07:00
committed by GitHub
parent bb64a0673d
commit 493bf0c7b3
12 changed files with 143 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
packages/grafana-ui/src/components/SingleStatShared/SingleStatValueEditor.tsx
View File

@@ -8,7 +8,7 @@ import {
PanelOptionsGroup,
StatsPicker,
UnitPicker,
StatID,
ReducerID,
SelectOptionItem,
} from '@grafana/ui';
@@ -27,7 +27,7 @@ export class SingleStatValueEditor extends PureComponent<Props> {
onUnitChange = (unit: SelectOptionItem<string>) => this.props.onChange({ ...this.props.value, unit: unit.value });
onStatsChange = (stats: string[]) => {
const stat = stats[0] || StatID.mean;
const stat = stats[0] || ReducerID.mean;
this.props.onChange({ ...this.props.value, stat });
};
@@ -65,7 +65,7 @@ export class SingleStatValueEditor extends PureComponent<Props> {
<StatsPicker
width={12}
placeholder="Choose Stat"
defaultStat={StatID.mean}
defaultStat={ReducerID.mean}
allowMultiple={false}
stats={[stat]}
onChange={this.onStatsChange}

8
packages/grafana-ui/src/components/SingleStatShared/shared.ts
View File

@@ -11,7 +11,7 @@ import {
SeriesData,
InterpolateFunction,
} from '../../types';
import { getStatsCalculators, calculateStats } from '../../utils/statsCalculator';
import { getFieldReducers, reduceField } from '../../utils/fieldReducer';
import { getDisplayProcessor } from '../../utils/displayValue';
export { SingleStatValueEditor } from './SingleStatValueEditor';
@@ -66,10 +66,10 @@ export const getSingleStatDisplayValues = (options: GetSingleStatDisplayValueOpt
// Show all fields that are not 'time'
if (column.type === FieldType.number) {
const stats = calculateStats({
const stats = reduceField({
series,
fieldIndex: i,
stats: [stat], // The stats to calculate
reducers: [stat], // The stats to calculate
nullValueMode: NullValueMode.Null,
});
@@ -124,7 +124,7 @@ export const sharedSingleStatMigrationCheck = (panel: PanelModel<SingleStatBaseO
// avg -> mean, current -> last, total -> sum
const { valueOptions } = options;
if (valueOptions && valueOptions.stat) {
valueOptions.stat = getStatsCalculators([valueOptions.stat]).map(s => s.id)[0];
valueOptions.stat = getFieldReducers([valueOptions.stat]).map(s => s.id)[0];
}
}
return options;

6
packages/grafana-ui/src/components/StatsPicker/StatsPicker.tsx
View File

@@ -5,7 +5,7 @@ import difference from 'lodash/difference';
import { Select } from '../index';
import { getStatsCalculators } from '../../utils/statsCalculator';
import { getFieldReducers } from '../../utils/fieldReducer';
import { SelectOptionItem } from '../Select/Select';
interface Props {
@@ -34,7 +34,7 @@ export class StatsPicker extends PureComponent<Props> {
checkInput = () => {
const { stats, allowMultiple, defaultStat, onChange } = this.props;
const current = getStatsCalculators(stats);
const current = getFieldReducers(stats);
if (current.length !== stats.length) {
const found = current.map(v => v.id);
const notFound = difference(stats, found);
@@ -65,7 +65,7 @@ export class StatsPicker extends PureComponent<Props> {
render() {
const { width, stats, allowMultiple, defaultStat, placeholder } = this.props;
const options = getStatsCalculators().map(s => {
const options = getFieldReducers().map(s => {
return {
value: s.id,
label: s.name,

52
packages/grafana-ui/src/utils/statsCalculator.test.ts → packages/grafana-ui/src/utils/fieldReducer.test.ts
View File

@@ -1,4 +1,4 @@
import { getStatsCalculators, StatID, calculateStats } from './statsCalculator';
import { getFieldReducers, ReducerID, reduceField } from './fieldReducer';
import _ from 'lodash';
@@ -10,28 +10,28 @@ describe('Stats Calculators', () => {
it('should load all standard stats', () => {
const names = [
StatID.sum,
StatID.max,
StatID.min,
StatID.logmin,
StatID.mean,
StatID.last,
StatID.first,
StatID.count,
StatID.range,
StatID.diff,
StatID.step,
StatID.delta,
// StatID.allIsZero,
// StatID.allIsNull,
ReducerID.sum,
ReducerID.max,
ReducerID.min,
ReducerID.logmin,
ReducerID.mean,
ReducerID.last,
ReducerID.first,
ReducerID.count,
ReducerID.range,
ReducerID.diff,
ReducerID.step,
ReducerID.delta,
// ReducerID.allIsZero,
// ReducerID.allIsNull,
];
const stats = getStatsCalculators(names);
const stats = getFieldReducers(names);
expect(stats.length).toBe(names.length);
});
it('should fail to load unknown stats', () => {
const names = ['not a stat', StatID.max, StatID.min, 'also not a stat'];
const stats = getStatsCalculators(names);
const names = ['not a stat', ReducerID.max, ReducerID.min, 'also not a stat'];
const stats = getFieldReducers(names);
expect(stats.length).toBe(2);
const found = stats.map(v => v.id);
@@ -42,10 +42,10 @@ describe('Stats Calculators', () => {
});
it('should calculate basic stats', () => {
const stats = calculateStats({
const stats = reduceField({
series: basicTable,
fieldIndex: 0,
stats: ['first', 'last', 'mean'],
reducers: ['first', 'last', 'mean'],
});
// First
@@ -59,10 +59,10 @@ describe('Stats Calculators', () => {
});
it('should support a single stat also', () => {
const stats = calculateStats({
const stats = reduceField({
series: basicTable,
fieldIndex: 0,
stats: ['first'],
reducers: ['first'],
});
// Should do the simple version that just looks up value
@@ -71,10 +71,10 @@ describe('Stats Calculators', () => {
});
it('should get non standard stats', () => {
const stats = calculateStats({
const stats = reduceField({
series: basicTable,
fieldIndex: 0,
stats: [StatID.distinctCount, StatID.changeCount],
reducers: [ReducerID.distinctCount, ReducerID.changeCount],
});
expect(stats.distinctCount).toEqual(2);
@@ -82,10 +82,10 @@ describe('Stats Calculators', () => {
});
it('should calculate step', () => {
const stats = calculateStats({
const stats = reduceField({
series: { fields: [{ name: 'A' }], rows: [[100], [200], [300], [400]] },
fieldIndex: 0,
stats: [StatID.step, StatID.delta],
reducers: [ReducerID.step, ReducerID.delta],
});
expect(stats.step).toEqual(100);

181
packages/grafana-ui/src/utils/statsCalculator.ts → packages/grafana-ui/src/utils/fieldReducer.ts
View File

@@ -3,7 +3,7 @@ import isNumber from 'lodash/isNumber';
import { SeriesData, NullValueMode } from '../types/index';
export enum StatID {
export enum ReducerID {
sum = 'sum',
max = 'max',
min = 'min',
@@ -24,14 +24,14 @@ export enum StatID {
allIsNull = 'allIsNull',
}
export interface FieldStats {
export interface FieldCalcs {
[key: string]: any;
}
// Internal function
type StatCalculator = (data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean) => FieldStats;
type FieldReducer = (data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean) => FieldCalcs;
export interface StatCalculatorInfo {
export interface FieldReducerInfo {
id: string;
name: string;
description: string;
@@ -40,16 +40,16 @@ export interface StatCalculatorInfo {
// Internal details
emptyInputResult?: any; // typically null, but some things like 'count' & 'sum' should be zero
standard: boolean; // The most common stats can all be calculated in a single pass
calculator?: StatCalculator;
reduce?: FieldReducer;
}
/**
* @param ids list of stat names or null to get all of them
*/
export function getStatsCalculators(ids?: string[]): StatCalculatorInfo[] {
export function getFieldReducers(ids?: string[]): FieldReducerInfo[] {
if (ids === null || ids === undefined) {
if (!hasBuiltIndex) {
getById(StatID.mean);
getById(ReducerID.mean);
}
return listOfStats;
}
@@ -60,53 +60,53 @@ export function getStatsCalculators(ids?: string[]): StatCalculatorInfo[] {
list.push(stat);
}
return list;
}, new Array<StatCalculatorInfo>());
}, new Array<FieldReducerInfo>());
}
export interface CalculateStatsOptions {
interface ReduceFieldOptions {
series: SeriesData;
fieldIndex: number;
stats: string[]; // The stats to calculate
reducers: string[]; // The stats to calculate
nullValueMode?: NullValueMode;
}
/**
* @returns an object with a key for each selected stat
*/
export function calculateStats(options: CalculateStatsOptions): FieldStats {
const { series, fieldIndex, stats, nullValueMode } = options;
export function reduceField(options: ReduceFieldOptions): FieldCalcs {
const { series, fieldIndex, reducers, nullValueMode } = options;
if (!stats || stats.length < 1) {
if (!reducers || reducers.length < 1) {
return {};
}
const queue = getStatsCalculators(stats);
const queue = getFieldReducers(reducers);
// Return early for empty series
// This lets the concrete implementations assume at least one row
if (!series.rows || series.rows.length < 1) {
const stats = {} as FieldStats;
for (const stat of queue) {
stats[stat.id] = stat.emptyInputResult !== null ? stat.emptyInputResult : null;
const calcs = {} as FieldCalcs;
for (const reducer of queue) {
calcs[reducer.id] = reducer.emptyInputResult !== null ? reducer.emptyInputResult : null;
}
return stats;
return calcs;
}
const ignoreNulls = nullValueMode === NullValueMode.Ignore;
const nullAsZero = nullValueMode === NullValueMode.AsZero;
// Avoid calculating all the standard stats if possible
if (queue.length === 1 && queue[0].calculator) {
return queue[0].calculator(series, fieldIndex, ignoreNulls, nullAsZero);
if (queue.length === 1 && queue[0].reduce) {
return queue[0].reduce(series, fieldIndex, ignoreNulls, nullAsZero);
}
// For now everything can use the standard stats
let values = standardStatsStat(series, fieldIndex, ignoreNulls, nullAsZero);
for (const calc of queue) {
if (!values.hasOwnProperty(calc.id) && calc.calculator) {
let values = doStandardCalcs(series, fieldIndex, ignoreNulls, nullAsZero);
for (const reducer of queue) {
if (!values.hasOwnProperty(reducer.id) && reducer.reduce) {
values = {
...values,
...calc.calculator(series, fieldIndex, ignoreNulls, nullAsZero),
...reducer.reduce(series, fieldIndex, ignoreNulls, nullAsZero),
};
}
}
@@ -121,30 +121,30 @@ export function calculateStats(options: CalculateStatsOptions): FieldStats {
// private registry of all stats
interface TableStatIndex {
[id: string]: StatCalculatorInfo;
[id: string]: FieldReducerInfo;
}
const listOfStats: StatCalculatorInfo[] = [];
const listOfStats: FieldReducerInfo[] = [];
const index: TableStatIndex = {};
let hasBuiltIndex = false;
function getById(id: string): StatCalculatorInfo | undefined {
function getById(id: string): FieldReducerInfo | undefined {
if (!hasBuiltIndex) {
[
{
id: StatID.last,
id: ReducerID.last,
name: 'Last',
description: 'Last Value (current)',
standard: true,
alias: 'current',
calculator: calculateLast,
reduce: calculateLast,
},
{ id: StatID.first, name: 'First', description: 'First Value', standard: true, calculator: calculateFirst },
{ id: StatID.min, name: 'Min', description: 'Minimum Value', standard: true },
{ id: StatID.max, name: 'Max', description: 'Maximum Value', standard: true },
{ id: StatID.mean, name: 'Mean', description: 'Average Value', standard: true, alias: 'avg' },
{ id: ReducerID.first, name: 'First', description: 'First Value', standard: true, reduce: calculateFirst },
{ id: ReducerID.min, name: 'Min', description: 'Minimum Value', standard: true },
{ id: ReducerID.max, name: 'Max', description: 'Maximum Value', standard: true },
{ id: ReducerID.mean, name: 'Mean', description: 'Average Value', standard: true, alias: 'avg' },
{
id: StatID.sum,
id: ReducerID.sum,
name: 'Total',
description: 'The sum of all values',
emptyInputResult: 0,
@@ -152,55 +152,55 @@ function getById(id: string): StatCalculatorInfo | undefined {
alias: 'total',
},
{
id: StatID.count,
id: ReducerID.count,
name: 'Count',
description: 'Number of values in response',
emptyInputResult: 0,
standard: true,
},
{
id: StatID.range,
id: ReducerID.range,
name: 'Range',
description: 'Difference between minimum and maximum values',
standard: true,
},
{
id: StatID.delta,
id: ReducerID.delta,
name: 'Delta',
description: 'Cumulative change in value',
standard: true,
},
{
id: StatID.step,
id: ReducerID.step,
name: 'Step',
description: 'Minimum interval between values',
standard: true,
},
{
id: StatID.diff,
id: ReducerID.diff,
name: 'Difference',
description: 'Difference between first and last values',
standard: true,
},
{
id: StatID.logmin,
id: ReducerID.logmin,
name: 'Min (above zero)',
description: 'Used for log min scale',
standard: true,
},
{
id: StatID.changeCount,
id: ReducerID.changeCount,
name: 'Change Count',
description: 'Number of times the value changes',
standard: false,
calculator: calculateChangeCount,
reduce: calculateChangeCount,
},
{
id: StatID.distinctCount,
id: ReducerID.distinctCount,
name: 'Distinct Count',
description: 'Number of distinct values',
standard: false,
calculator: calculateDistinctCount,
reduce: calculateDistinctCount,
},
].forEach(info => {
const { id, alias } = info;
@@ -222,13 +222,8 @@ function getById(id: string): StatCalculatorInfo | undefined {
return index[id];
}
function standardStatsStat(
data: SeriesData,
fieldIndex: number,
ignoreNulls: boolean,
nullAsZero: boolean
): FieldStats {
const stats = {
function doStandardCalcs(data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean): FieldCalcs {
const calcs = {
sum: 0,
max: -Number.MAX_VALUE,
min: Number.MAX_VALUE,
@@ -247,7 +242,7 @@ function standardStatsStat(
// Just used for calcutations -- not exposed as a stat
previousDeltaUp: true,
} as FieldStats;
} as FieldCalcs;
for (let i = 0; i < data.rows.length; i++) {
let currentValue = data.rows[i][fieldIndex];
@@ -262,94 +257,94 @@ function standardStatsStat(
}
if (currentValue !== null) {
const isFirst = stats.first === null;
const isFirst = calcs.first === null;
if (isFirst) {
stats.first = currentValue;
calcs.first = currentValue;
}
if (isNumber(currentValue)) {
stats.sum += currentValue;
stats.allIsNull = false;
stats.nonNullCount++;
calcs.sum += currentValue;
calcs.allIsNull = false;
calcs.nonNullCount++;
if (!isFirst) {
const step = currentValue - stats.last!;
if (stats.step > step) {
stats.step = step; // the minimum interval
const step = currentValue - calcs.last!;
if (calcs.step > step) {
calcs.step = step; // the minimum interval
}
if (stats.last! > currentValue) {
if (calcs.last! > currentValue) {
// counter reset
stats.previousDeltaUp = false;
calcs.previousDeltaUp = false;
if (i === data.rows.length - 1) {
// reset on last
stats.delta += currentValue;
calcs.delta += currentValue;
}
} else {
if (stats.previousDeltaUp) {
stats.delta += step; // normal increment
if (calcs.previousDeltaUp) {
calcs.delta += step; // normal increment
} else {
stats.delta += currentValue; // account for counter reset
calcs.delta += currentValue; // account for counter reset
}
stats.previousDeltaUp = true;
calcs.previousDeltaUp = true;
}
}
if (currentValue > stats.max) {
stats.max = currentValue;
if (currentValue > calcs.max) {
calcs.max = currentValue;
}
if (currentValue < stats.min) {
stats.min = currentValue;
if (currentValue < calcs.min) {
calcs.min = currentValue;
}
if (currentValue < stats.logmin && currentValue > 0) {
stats.logmin = currentValue;
if (currentValue < calcs.logmin && currentValue > 0) {
calcs.logmin = currentValue;
}
}
if (currentValue !== 0) {
stats.allIsZero = false;
calcs.allIsZero = false;
}
stats.last = currentValue;
calcs.last = currentValue;
}
}
if (stats.max === -Number.MAX_VALUE) {
stats.max = null;
if (calcs.max === -Number.MAX_VALUE) {
calcs.max = null;
}
if (stats.min === Number.MAX_VALUE) {
stats.min = null;
if (calcs.min === Number.MAX_VALUE) {
calcs.min = null;
}
if (stats.step === Number.MAX_VALUE) {
stats.step = null;
if (calcs.step === Number.MAX_VALUE) {
calcs.step = null;
}
if (stats.nonNullCount > 0) {
stats.mean = stats.sum! / stats.nonNullCount;
if (calcs.nonNullCount > 0) {
calcs.mean = calcs.sum! / calcs.nonNullCount;
}
if (stats.max !== null && stats.min !== null) {
stats.range = stats.max - stats.min;
if (calcs.max !== null && calcs.min !== null) {
calcs.range = calcs.max - calcs.min;
}
if (stats.first !== null && stats.last !== null) {
if (isNumber(stats.first) && isNumber(stats.last)) {
stats.diff = stats.last - stats.first;
if (calcs.first !== null && calcs.last !== null) {
if (isNumber(calcs.first) && isNumber(calcs.last)) {
calcs.diff = calcs.last - calcs.first;
}
}
return stats;
return calcs;
}
function calculateFirst(data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean): FieldStats {
function calculateFirst(data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean): FieldCalcs {
return { first: data.rows[0][fieldIndex] };
}
function calculateLast(data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean): FieldStats {
function calculateLast(data: SeriesData, fieldIndex: number, ignoreNulls: boolean, nullAsZero: boolean): FieldCalcs {
return { last: data.rows[data.rows.length - 1][fieldIndex] };
}
@@ -358,7 +353,7 @@ function calculateChangeCount(
fieldIndex: number,
ignoreNulls: boolean,
nullAsZero: boolean
): FieldStats {
): FieldCalcs {
let count = 0;
let first = true;
let last: any = null;
@@ -387,7 +382,7 @@ function calculateDistinctCount(
fieldIndex: number,
ignoreNulls: boolean,
nullAsZero: boolean
): FieldStats {
): FieldCalcs {
const distinct = new Set<any>();
for (let i = 0; i < data.rows.length; i++) {
let currentValue = data.rows[i][fieldIndex];

2
packages/grafana-ui/src/utils/index.ts
View File

@@ -5,7 +5,7 @@ export * from './namedColorsPalette';
export * from './thresholds';
export * from './string';
export * from './csv';
export * from './statsCalculator';
export * from './fieldReducer';
export * from './displayValue';
export * from './deprecationWarning';
export * from './logs';