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

CloudWatch: filter alert queries (#47222)

Browse Source
pull/44520/head^2
Isabella Siu 3 years ago committed by GitHub
parent 1c34cc8b91
commit b1c68b5a12
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 126 additions and 117 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. 184
      public/app/plugins/datasource/cloudwatch/datasource.test.ts
  2. 59
      public/app/plugins/datasource/cloudwatch/datasource.ts

184
public/app/plugins/datasource/cloudwatch/datasource.test.ts
Unescape View File

@ -10,8 +10,13 @@ import {
namespaceVariable,
setupMockedDataSource,
} from './__mocks__/CloudWatchDataSource';
import { CloudWatchDatasource } from './datasource';
import { CloudWatchLogsQueryStatus, CloudWatchMetricsQuery, MetricEditorMode, MetricQueryType } from './types';
import {
CloudWatchLogsQuery,
CloudWatchLogsQueryStatus,
CloudWatchMetricsQuery,
MetricEditorMode,
MetricQueryType,
} from './types';
describe('datasource', () => {
describe('query', () => {
@ -144,111 +149,124 @@ describe('datasource', () => {
});
});
describe('filterMetricQuery', () => {
let baseQuery: CloudWatchMetricsQuery;
let datasource: CloudWatchDatasource;
beforeEach(() => {
datasource = setupMockedDataSource().datasource;
baseQuery = {
describe('filterQuery', () => {
const datasource = setupMockedDataSource().datasource;
describe('CloudWatchLogsQuery', () => {
const baseQuery: CloudWatchLogsQuery = {
queryMode: 'Logs',
id: '',
region: 'us-east-2',
namespace: '',
period: '',
alias: '',
metricName: '',
dimensions: {},
matchExact: true,
statistic: '',
expression: '',
region: '',
refId: '',
logGroupNames: ['foo', 'bar'],
};
it('should return false if empty logGroupNames', () => {
expect(datasource.filterQuery({ ...baseQuery, logGroupNames: undefined })).toBeFalsy();
});
it('should return true if has logGroupNames', () => {
expect(datasource.filterQuery(baseQuery)).toBeTruthy();
});
});
it('should error if invalid mode', async () => {
expect(() => datasource.filterMetricQuery(baseQuery)).toThrowError('invalid metric editor mode');
});
describe('metric search queries', () => {
describe('CloudWatchMetricsQuery', () => {
let baseQuery: CloudWatchMetricsQuery;
beforeEach(() => {
datasource = setupMockedDataSource().datasource;
baseQuery = {
...baseQuery,
namespace: 'AWS/EC2',
metricName: 'CPUUtilization',
statistic: 'Average',
metricQueryType: MetricQueryType.Search,
metricEditorMode: MetricEditorMode.Builder,
id: '',
region: 'us-east-2',
namespace: '',
period: '',
alias: '',
metricName: '',
dimensions: {},
matchExact: true,
statistic: '',
expression: '',
refId: '',
};
});
it('should not allow builder queries that dont have namespace, metric or statistic', async () => {
expect(datasource.filterMetricQuery({ ...baseQuery, statistic: undefined })).toBeFalsy();
expect(datasource.filterMetricQuery({ ...baseQuery, metricName: undefined })).toBeFalsy();
expect(datasource.filterMetricQuery({ ...baseQuery, namespace: '' })).toBeFalsy();
it('should error if invalid mode', async () => {
expect(() => datasource.filterQuery(baseQuery)).toThrowError('invalid metric editor mode');
});
it('should allow builder queries that have namespace, metric or statistic', async () => {
expect(datasource.filterMetricQuery(baseQuery)).toBeTruthy();
});
describe('metric search queries', () => {
beforeEach(() => {
baseQuery = {
...baseQuery,
namespace: 'AWS/EC2',
metricName: 'CPUUtilization',
statistic: 'Average',
metricQueryType: MetricQueryType.Search,
metricEditorMode: MetricEditorMode.Builder,
};
});
it('should not allow code queries that dont have an expression', async () => {
expect(
datasource.filterMetricQuery({ ...baseQuery, expression: undefined, metricEditorMode: MetricEditorMode.Code })
).toBeFalsy();
});
it('should not allow builder queries that dont have namespace, metric or statistic', async () => {
expect(datasource.filterQuery({ ...baseQuery, statistic: undefined })).toBeFalsy();
expect(datasource.filterQuery({ ...baseQuery, metricName: undefined })).toBeFalsy();
expect(datasource.filterQuery({ ...baseQuery, namespace: '' })).toBeFalsy();
});
it('should allow code queries that have an expression', async () => {
expect(
datasource.filterMetricQuery({ ...baseQuery, expression: 'x * 2', metricEditorMode: MetricEditorMode.Code })
).toBeTruthy();
});
});
it('should allow builder queries that have namespace, metric or statistic', async () => {
expect(datasource.filterQuery(baseQuery)).toBeTruthy();
});
describe('metric search expression queries', () => {
beforeEach(() => {
datasource = setupMockedDataSource().datasource;
baseQuery = {
...baseQuery,
metricQueryType: MetricQueryType.Search,
metricEditorMode: MetricEditorMode.Code,
};
});
it('should not allow code queries that dont have an expression', async () => {
expect(
datasource.filterQuery({ ...baseQuery, expression: undefined, metricEditorMode: MetricEditorMode.Code })
).toBeFalsy();
});
it('should not allow queries that dont have an expresssion', async () => {
const valid = datasource.filterMetricQuery(baseQuery);
expect(valid).toBeFalsy();
it('should allow code queries that have an expression', async () => {
expect(
datasource.filterQuery({ ...baseQuery, expression: 'x * 2', metricEditorMode: MetricEditorMode.Code })
).toBeTruthy();
});
});
it('should allow queries that have an expresssion', async () => {
baseQuery.expression = 'SUM([a,x])';
const valid = datasource.filterMetricQuery(baseQuery);
expect(valid).toBeTruthy();
});
});
describe('metric search expression queries', () => {
beforeEach(() => {
baseQuery = {
...baseQuery,
metricQueryType: MetricQueryType.Search,
metricEditorMode: MetricEditorMode.Code,
};
});
describe('metric query queries', () => {
beforeEach(() => {
datasource = setupMockedDataSource().datasource;
baseQuery = {
...baseQuery,
metricQueryType: MetricQueryType.Query,
metricEditorMode: MetricEditorMode.Code,
};
});
it('should not allow queries that dont have an expression', async () => {
const valid = datasource.filterQuery(baseQuery);
expect(valid).toBeFalsy();
});
it('should not allow queries that dont have a sql expresssion', async () => {
const valid = datasource.filterMetricQuery(baseQuery);
expect(valid).toBeFalsy();
it('should allow queries that have an expression', async () => {
baseQuery.expression = 'SUM([a,x])';
const valid = datasource.filterQuery(baseQuery);
expect(valid).toBeTruthy();
});
});
it('should allow queries that have a sql expresssion', async () => {
baseQuery.sqlExpression = 'select SUM(CPUUtilization) from "AWS/EC2"';
const valid = datasource.filterMetricQuery(baseQuery);
expect(valid).toBeTruthy();
describe('metric query queries', () => {
beforeEach(() => {
baseQuery = {
...baseQuery,
metricQueryType: MetricQueryType.Query,
metricEditorMode: MetricEditorMode.Code,
};
});
it('should not allow queries that dont have a sql expresssion', async () => {
const valid = datasource.filterQuery(baseQuery);
expect(valid).toBeFalsy();
});
it('should allow queries that have a sql expresssion', async () => {
baseQuery.sqlExpression = 'select SUM(CPUUtilization) from "AWS/EC2"';
const valid = datasource.filterQuery(baseQuery);
expect(valid).toBeTruthy();
});
});
});
});
describe('resource requests', () => {
it('should map resource response to metric response', async () => {
const datasource = setupMockedDataSource().datasource;

59
public/app/plugins/datasource/cloudwatch/datasource.ts
Unescape View File

@ -234,22 +234,15 @@ export class CloudWatchDatasource
);
};
filterMetricQuery({
region,
metricQueryType,
metricEditorMode,
expression,
metricName,
namespace,
sqlExpression,
statistic,
dimensions,
...rest
}: CloudWatchMetricsQuery): boolean {
filterQuery(query: CloudWatchQuery): boolean {
if (query.queryMode === 'Logs') {
return !!query.logGroupNames?.length;
}
const { region, metricQueryType, metricEditorMode, expression, metricName, namespace, sqlExpression, statistic } =
query;
if (!region) {
return false;
}
if (metricQueryType === MetricQueryType.Search && metricEditorMode === MetricEditorMode.Builder) {
return !!namespace && !!metricName && !!statistic;
} else if (metricQueryType === MetricQueryType.Search && metricEditorMode === MetricEditorMode.Code) {
@ -266,27 +259,25 @@ export class CloudWatchDatasource
metricQueries: CloudWatchMetricsQuery[],
options: DataQueryRequest<CloudWatchQuery>
): Observable<DataQueryResponse> => {
const validMetricsQueries = metricQueries
.filter(this.filterMetricQuery)
.map((item: CloudWatchMetricsQuery): MetricQuery => {
item.region = this.templateSrv.replace(this.getActualRegion(item.region), options.scopedVars);
item.namespace = this.replace(item.namespace, options.scopedVars, true, 'namespace');
item.metricName = this.replace(item.metricName, options.scopedVars, true, 'metric name');
item.dimensions = this.convertDimensionFormat(item.dimensions ?? {}, options.scopedVars);
item.statistic = this.templateSrv.replace(item.statistic, options.scopedVars);
item.period = String(this.getPeriod(item, options)); // use string format for period in graph query, and alerting
item.id = this.templateSrv.replace(item.id, options.scopedVars);
item.expression = this.templateSrv.replace(item.expression, options.scopedVars);
item.sqlExpression = this.templateSrv.replace(item.sqlExpression, options.scopedVars, 'raw');
return {
intervalMs: options.intervalMs,
maxDataPoints: options.maxDataPoints,
...item,
type: 'timeSeriesQuery',
datasource: this.getRef(),
};
});
const validMetricsQueries = metricQueries.map((item: CloudWatchMetricsQuery): MetricQuery => {
item.region = this.templateSrv.replace(this.getActualRegion(item.region), options.scopedVars);
item.namespace = this.replace(item.namespace, options.scopedVars, true, 'namespace');
item.metricName = this.replace(item.metricName, options.scopedVars, true, 'metric name');
item.dimensions = this.convertDimensionFormat(item.dimensions ?? {}, options.scopedVars);
item.statistic = this.templateSrv.replace(item.statistic, options.scopedVars);
item.period = String(this.getPeriod(item, options)); // use string format for period in graph query, and alerting
item.id = this.templateSrv.replace(item.id, options.scopedVars);
item.expression = this.templateSrv.replace(item.expression, options.scopedVars);
item.sqlExpression = this.templateSrv.replace(item.sqlExpression, options.scopedVars, 'raw');
return {
intervalMs: options.intervalMs,
maxDataPoints: options.maxDataPoints,
...item,
type: 'timeSeriesQuery',
datasource: this.getRef(),
};
});
// No valid targets, return the empty result to save a round trip.
if (isEmpty(validMetricsQueries)) {

Write Preview
Loading…
Cancel
Save