Alerting: app specific query editors for Loki and Prometheus (#34365)

* Adding simplified version of query editor based on app flag.

* cleaned up the absolute time range.

* changing placeholder text.

* updated snapshot.

* added some tests.

* adding loki query editor tests.

* updating snapshots.
mckn/cloud-alerting-viz
Marcus Andersson 4 years ago committed by GitHub
parent f48708bb9e
commit 8ddf6de6e7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 1
      packages/grafana-data/src/types/app.ts
  2. 1
      packages/grafana-data/src/types/datasource.ts
  3. 68
      public/app/features/alerting/unified/components/rule-editor/ExpressionEditor.tsx
  4. 7
      public/app/plugins/datasource/loki/components/AnnotationsQueryEditor.tsx
  5. 4
      public/app/plugins/datasource/loki/components/LokiExploreQueryEditor.tsx
  6. 19
      public/app/plugins/datasource/loki/components/LokiQueryEditor.tsx
  7. 59
      public/app/plugins/datasource/loki/components/LokiQueryEditorByApp.test.tsx
  8. 18
      public/app/plugins/datasource/loki/components/LokiQueryEditorByApp.tsx
  9. 25
      public/app/plugins/datasource/loki/components/LokiQueryEditorForAlerting.tsx
  10. 20
      public/app/plugins/datasource/loki/components/LokiQueryField.tsx
  11. 6
      public/app/plugins/datasource/loki/components/__snapshots__/LokiExploreQueryEditor.test.tsx.snap
  12. 14
      public/app/plugins/datasource/loki/components/__snapshots__/LokiQueryEditor.test.tsx.snap
  13. 5
      public/app/plugins/datasource/loki/components/types.ts
  14. 4
      public/app/plugins/datasource/loki/module.ts
  15. 17
      public/app/plugins/datasource/prometheus/components/PromQueryEditor.tsx
  16. 64
      public/app/plugins/datasource/prometheus/components/PromQueryEditorByApp.test.tsx
  17. 18
      public/app/plugins/datasource/prometheus/components/PromQueryEditorByApp.tsx
  18. 25
      public/app/plugins/datasource/prometheus/components/PromQueryEditorForAlerting.tsx
  19. 11
      public/app/plugins/datasource/prometheus/components/PromQueryField.tsx
  20. 1
      public/app/plugins/datasource/prometheus/components/__snapshots__/PromQueryEditor.test.tsx.snap
  21. 5
      public/app/plugins/datasource/prometheus/components/types.ts
  22. 4
      public/app/plugins/datasource/prometheus/module.ts
  23. 5
      public/app/plugins/datasource/tempo/QueryField.tsx

@ -7,6 +7,7 @@ export enum CoreApp {
Dashboard = 'dashboard',
Explore = 'explore',
Unknown = 'unknown',
CloudAlerting = 'cloud-alerting',
}
export interface AppRootProps<T = KeyValue> {

@ -367,6 +367,7 @@ export interface QueryEditorProps<
exploreId?: any;
history?: HistoryItem[];
queries?: DataQuery[];
app?: CoreApp;
}
// TODO: not really needed but used as type in some data sources and in DataQueryRequest

@ -1,5 +1,10 @@
import { TextArea } from '@grafana/ui';
import React, { FC } from 'react';
import React, { FC, useCallback, useMemo, useState } from 'react';
import { noop } from 'lodash';
import { CoreApp, DataQuery } from '@grafana/data';
import { getDataSourceSrv } from '@grafana/runtime';
import { useAsync } from 'react-use';
import { PromQuery } from 'app/plugins/datasource/prometheus/types';
import { LokiQuery } from 'app/plugins/datasource/loki/types';
interface Props {
value?: string;
@ -7,13 +12,62 @@ interface Props {
dataSourceName: string; // will be a prometheus or loki datasource
}
// @TODO implement proper prom/loki query editor here
export const ExpressionEditor: FC<Props> = ({ value, onChange, dataSourceName }) => {
const { mapToValue, mapToQuery } = useQueryMappers(dataSourceName);
const [query, setQuery] = useState(mapToQuery({ refId: 'A', hide: false }, value));
const { error, loading, value: dataSource } = useAsync(() => {
return getDataSourceSrv().get(dataSourceName);
}, [dataSourceName]);
const onChangeQuery = useCallback(
(query: DataQuery) => {
setQuery(query);
onChange(mapToValue(query));
},
[onChange, mapToValue]
);
if (loading || dataSource?.name !== dataSourceName) {
return null;
}
if (error || !dataSource || !dataSource?.components?.QueryEditor) {
const errorMessage = error?.message || 'Data source plugin does not export any Query Editor component';
return <div>Could not load query editor due to: {errorMessage}</div>;
}
const QueryEditor = dataSource?.components?.QueryEditor;
return (
<TextArea
placeholder="Enter a promql expression"
value={value}
onChange={(evt) => onChange((evt.target as HTMLTextAreaElement).value)}
<QueryEditor
query={query}
queries={[query]}
app={CoreApp.CloudAlerting}
onChange={onChangeQuery}
onRunQuery={noop}
datasource={dataSource}
/>
);
};
type QueryMappers<T extends DataQuery = DataQuery> = {
mapToValue: (query: T) => string;
mapToQuery: (existing: T, value: string | undefined) => T;
};
function useQueryMappers(dataSourceName: string): QueryMappers {
return useMemo(() => {
const settings = getDataSourceSrv().getInstanceSettings(dataSourceName);
switch (settings?.type) {
case 'loki':
case 'prometheus':
return {
mapToValue: (query: PromQuery | LokiQuery) => query.expr,
mapToQuery: (existing: DataQuery, value: string | undefined) => ({ ...existing, expr: value }),
};
default:
throw new Error(`${dataSourceName} is not supported as an expression editor`);
}
}, [dataSourceName]);
}

@ -17,12 +17,6 @@ interface Props {
export const LokiAnnotationsQueryEditor = memo(function LokiAnnotationQueryEditor(props: Props) {
const { expr, maxLines, instant, datasource, onChange } = props;
// Timerange to get existing labels from. Hard coding like this seems to be good enough right now.
const absoluteRange = {
from: Date.now() - 10000,
to: Date.now(),
};
const queryWithRefId: LokiQuery = {
refId: '',
expr,
@ -38,7 +32,6 @@ export const LokiAnnotationsQueryEditor = memo(function LokiAnnotationQueryEdito
onRunQuery={() => {}}
onBlur={() => {}}
history={[]}
absoluteRange={absoluteRange}
ExtraFieldElement={
<LokiOptionFields
queryType={queryWithRefId.instant ? 'instant' : 'range'}

@ -11,8 +11,7 @@ import { LokiOptionFields } from './LokiOptionFields';
type Props = ExploreQueryFieldProps<LokiDatasource, LokiQuery, LokiOptions>;
export function LokiExploreQueryEditor(props: Props) {
const { range, query, data, datasource, history, onChange, onRunQuery } = props;
const absoluteTimeRange = { from: range!.from!.valueOf(), to: range!.to!.valueOf() }; // Range here is never optional
const { query, data, datasource, history, onChange, onRunQuery } = props;
return (
<LokiQueryField
@ -23,7 +22,6 @@ export function LokiExploreQueryEditor(props: Props) {
onRunQuery={onRunQuery}
history={history}
data={data}
absoluteRange={absoluteTimeRange}
ExtraFieldElement={
<LokiOptionFields
queryType={query.instant ? 'instant' : 'range'}

@ -1,19 +1,14 @@
// Libraries
import React, { memo } from 'react';
import React from 'react';
// Types
import { QueryEditorProps } from '@grafana/data';
import { InlineFormLabel } from '@grafana/ui';
import { LokiDatasource } from '../datasource';
import { LokiQuery, LokiOptions } from '../types';
import { LokiQueryField } from './LokiQueryField';
import { LokiOptionFields } from './LokiOptionFields';
import { LokiQueryEditorProps } from './types';
type Props = QueryEditorProps<LokiDatasource, LokiQuery, LokiOptions>;
export function LokiQueryEditor(props: Props) {
const { range, query, data, datasource, onChange, onRunQuery } = props;
const absoluteTimeRange = { from: range!.from!.valueOf(), to: range!.to!.valueOf() }; // Range here is never optional
export function LokiQueryEditor(props: LokiQueryEditorProps) {
const { query, data, datasource, onChange, onRunQuery } = props;
const onLegendChange = (e: React.SyntheticEvent<HTMLInputElement>) => {
const nextQuery = { ...query, legendFormat: e.currentTarget.value };
@ -51,7 +46,7 @@ export function LokiQueryEditor(props: Props) {
onBlur={onRunQuery}
history={[]}
data={data}
absoluteRange={absoluteTimeRange}
data-testid={testIds.editor}
ExtraFieldElement={
<>
<LokiOptionFields
@ -69,4 +64,6 @@ export function LokiQueryEditor(props: Props) {
);
}
export default memo(LokiQueryEditor);
export const testIds = {
editor: 'loki-editor',
};

@ -0,0 +1,59 @@
import React from 'react';
import { render, RenderResult } from '@testing-library/react';
import { CoreApp } from '@grafana/data';
import { noop } from 'lodash';
import { LokiDatasource } from '../datasource';
import { testIds as alertingTestIds } from './LokiQueryEditorForAlerting';
import { testIds as regularTestIds } from './LokiQueryEditor';
import LokiQueryEditorByApp from './LokiQueryEditorByApp';
function setup(app: CoreApp): RenderResult {
const dataSource = ({
languageProvider: {
start: () => Promise.resolve([]),
getSyntax: () => {},
getLabelKeys: () => [],
metrics: [],
},
} as unknown) as LokiDatasource;
return render(
<LokiQueryEditorByApp
app={app}
onChange={noop}
onRunQuery={noop}
datasource={dataSource}
query={{ refId: 'A', expr: '' }}
/>
);
}
describe('LokiQueryEditorByApp', () => {
it('should render simplified query editor for cloud alerting', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.CloudAlerting);
expect(getByTestId(alertingTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(regularTestIds.editor)).toBeNull();
});
it('should render regular query editor for unkown apps', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.Unknown);
expect(getByTestId(regularTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(alertingTestIds.editor)).toBeNull();
});
it('should render regular query editor for explore', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.Explore);
expect(getByTestId(regularTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(alertingTestIds.editor)).toBeNull();
});
it('should render regular query editor for dashboard', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.Dashboard);
expect(getByTestId(regularTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(alertingTestIds.editor)).toBeNull();
});
});

@ -0,0 +1,18 @@
import React, { memo } from 'react';
import { CoreApp } from '@grafana/data';
import { LokiQueryEditorProps } from './types';
import { LokiQueryEditor } from './LokiQueryEditor';
import { LokiQueryEditorForAlerting } from './LokiQueryEditorForAlerting';
export function LokiQueryEditorByApp(props: LokiQueryEditorProps) {
const { app } = props;
switch (app) {
case CoreApp.CloudAlerting:
return <LokiQueryEditorForAlerting {...props} />;
default:
return <LokiQueryEditor {...props} />;
}
}
export default memo(LokiQueryEditorByApp);

@ -0,0 +1,25 @@
import React from 'react';
import { LokiQueryField } from './LokiQueryField';
import { LokiQueryEditorProps } from './types';
export function LokiQueryEditorForAlerting(props: LokiQueryEditorProps) {
const { query, data, datasource, onChange, onRunQuery } = props;
return (
<LokiQueryField
datasource={datasource}
query={query}
onChange={onChange}
onRunQuery={onRunQuery}
onBlur={onRunQuery}
history={[]}
data={data}
placeholder="Enter a Loki query"
data-testid={testIds.editor}
/>
);
}
export const testIds = {
editor: 'loki-editor-cloud-alerting',
};

@ -18,7 +18,7 @@ import { Plugin, Node } from 'slate';
import { LokiLabelBrowser } from './LokiLabelBrowser';
// Types
import { ExploreQueryFieldProps, AbsoluteTimeRange } from '@grafana/data';
import { ExploreQueryFieldProps } from '@grafana/data';
import { LokiQuery, LokiOptions } from '../types';
import { LanguageMap, languages as prismLanguages } from 'prismjs';
import LokiLanguageProvider, { LokiHistoryItem } from '../language_provider';
@ -63,8 +63,9 @@ function willApplySuggestion(suggestion: string, { typeaheadContext, typeaheadTe
export interface LokiQueryFieldProps extends ExploreQueryFieldProps<LokiDatasource, LokiQuery, LokiOptions> {
history: LokiHistoryItem[];
absoluteRange: AbsoluteTimeRange;
ExtraFieldElement?: ReactNode;
placeholder?: string;
'data-testid'?: string;
}
interface LokiQueryFieldState {
@ -138,7 +139,13 @@ export class LokiQueryField extends React.PureComponent<LokiQueryFieldProps, Lok
};
render() {
const { ExtraFieldElement, query, datasource } = this.props;
const {
ExtraFieldElement,
query,
datasource,
placeholder = 'Enter a Loki query (run with Shift+Enter)',
} = this.props;
const { labelsLoaded, labelBrowserVisible } = this.state;
const lokiLanguageProvider = datasource.languageProvider as LokiLanguageProvider;
const cleanText = datasource.languageProvider ? lokiLanguageProvider.cleanText : undefined;
@ -148,7 +155,10 @@ export class LokiQueryField extends React.PureComponent<LokiQueryFieldProps, Lok
return (
<>
<div className="gf-form-inline gf-form-inline--xs-view-flex-column flex-grow-1">
<div
className="gf-form-inline gf-form-inline--xs-view-flex-column flex-grow-1"
data-testid={this.props['data-testid']}
>
<button
className="gf-form-label query-keyword pointer"
onClick={this.onClickChooserButton}
@ -167,7 +177,7 @@ export class LokiQueryField extends React.PureComponent<LokiQueryFieldProps, Lok
onChange={this.onChangeQuery}
onBlur={this.props.onBlur}
onRunQuery={this.props.onRunQuery}
placeholder="Enter a Loki query (run with Shift+Enter)"
placeholder={placeholder}
portalOrigin="loki"
/>
</div>

@ -17,12 +17,6 @@ exports[`LokiExploreQueryEditor should render component 1`] = `
queryType="range"
/>
}
absoluteRange={
Object {
"from": 1577836800000,
"to": 1577923200000,
}
}
data={
Object {
"request": Object {

@ -43,12 +43,7 @@ exports[`Render LokiQueryEditor with legend should render 1`] = `
</div>
</React.Fragment>
}
absoluteRange={
Object {
"from": 1577836800000,
"to": 1577923200000,
}
}
data-testid="loki-editor"
datasource={Object {}}
history={Array []}
onBlur={[MockFunction]}
@ -107,12 +102,7 @@ exports[`Render LokiQueryEditor with legend should update timerange 1`] = `
</div>
</React.Fragment>
}
absoluteRange={
Object {
"from": 1546300800000,
"to": 1577923200000,
}
}
data-testid="loki-editor"
datasource={Object {}}
history={Array []}
onBlur={[MockFunction]}

@ -0,0 +1,5 @@
import { QueryEditorProps } from '@grafana/data';
import LokiDatasource from '../datasource';
import { LokiOptions, LokiQuery } from '../types';
export type LokiQueryEditorProps = QueryEditorProps<LokiDatasource, LokiQuery, LokiOptions>;

@ -3,12 +3,12 @@ import Datasource from './datasource';
import LokiCheatSheet from './components/LokiCheatSheet';
import LokiExploreQueryEditor from './components/LokiExploreQueryEditor';
import LokiQueryEditor from './components/LokiQueryEditor';
import LokiQueryEditorByApp from './components/LokiQueryEditorByApp';
import { LokiAnnotationsQueryCtrl } from './LokiAnnotationsQueryCtrl';
import { ConfigEditor } from './configuration/ConfigEditor';
export const plugin = new DataSourcePlugin(Datasource)
.setQueryEditor(LokiQueryEditor)
.setQueryEditor(LokiQueryEditorByApp)
.setConfigEditor(ConfigEditor)
.setExploreQueryField(LokiExploreQueryEditor)
.setQueryEditorHelp(LokiCheatSheet)

@ -3,18 +3,16 @@ import React, { PureComponent } from 'react';
// Types
import { InlineFormLabel, LegacyForms, Select } from '@grafana/ui';
import { QueryEditorProps, SelectableValue } from '@grafana/data';
import { PrometheusDatasource } from '../datasource';
import { PromOptions, PromQuery } from '../types';
import { SelectableValue } from '@grafana/data';
import { PromQuery } from '../types';
import PromQueryField from './PromQueryField';
import PromLink from './PromLink';
import { PromExemplarField } from './PromExemplarField';
import { PromQueryEditorProps } from './types';
const { Switch } = LegacyForms;
export type Props = QueryEditorProps<PrometheusDatasource, PromQuery, PromOptions>;
const FORMAT_OPTIONS: Array<SelectableValue<string>> = [
{ label: 'Time series', value: 'time_series' },
{ label: 'Table', value: 'table' },
@ -35,11 +33,11 @@ interface State {
exemplar: boolean;
}
export class PromQueryEditor extends PureComponent<Props, State> {
export class PromQueryEditor extends PureComponent<PromQueryEditorProps, State> {
// Query target to be modified and used for queries
query: PromQuery;
constructor(props: Props) {
constructor(props: PromQueryEditorProps) {
super(props);
// Use default query to prevent undefined input values
const defaultQuery: Partial<PromQuery> = { expr: '', legendFormat: '', interval: '', exemplar: true };
@ -118,6 +116,7 @@ export class PromQueryEditor extends PureComponent<Props, State> {
onChange={this.onFieldChange}
history={[]}
data={data}
data-testid={testIds.editor}
ExtraFieldElement={
<div className="gf-form-inline">
<div className="gf-form">
@ -198,3 +197,7 @@ export class PromQueryEditor extends PureComponent<Props, State> {
);
}
}
export const testIds = {
editor: 'prom-editor',
};

@ -0,0 +1,64 @@
import React from 'react';
import { render, RenderResult } from '@testing-library/react';
import { PromQueryEditorByApp } from './PromQueryEditorByApp';
import { CoreApp } from '@grafana/data';
import { noop } from 'lodash';
import { Observable } from 'rxjs';
import { first } from 'rxjs/operators';
import { PrometheusDatasource } from '../datasource';
import { testIds as alertingTestIds } from './PromQueryEditorForAlerting';
import { testIds as regularTestIds } from './PromQueryEditor';
function setup(app: CoreApp): RenderResult {
const dataSource = ({
createQuery: jest.fn((q) => q),
getPrometheusTime: jest.fn((date, roundup) => 123),
languageProvider: {
start: () => Promise.resolve([]),
syntax: () => {},
getLabelKeys: () => [],
metrics: [],
},
exemplarErrors: new Observable().pipe(first()),
} as unknown) as PrometheusDatasource;
return render(
<PromQueryEditorByApp
app={app}
onChange={noop}
onRunQuery={noop}
datasource={dataSource}
query={{ refId: 'A', expr: '' }}
/>
);
}
describe('PromQueryEditorByApp', () => {
it('should render simplified query editor for cloud alerting', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.CloudAlerting);
expect(getByTestId(alertingTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(regularTestIds.editor)).toBeNull();
});
it('should render regular query editor for unkown apps', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.Unknown);
expect(getByTestId(regularTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(alertingTestIds.editor)).toBeNull();
});
it('should render regular query editor for explore', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.Explore);
expect(getByTestId(regularTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(alertingTestIds.editor)).toBeNull();
});
it('should render regular query editor for dashboard', () => {
const { getByTestId, queryByTestId } = setup(CoreApp.Dashboard);
expect(getByTestId(regularTestIds.editor)).toBeInTheDocument();
expect(queryByTestId(alertingTestIds.editor)).toBeNull();
});
});

@ -0,0 +1,18 @@
import React, { memo } from 'react';
import { CoreApp } from '@grafana/data';
import { PromQueryEditorProps } from './types';
import { PromQueryEditor } from './PromQueryEditor';
import { PromQueryEditorForAlerting } from './PromQueryEditorForAlerting';
export function PromQueryEditorByApp(props: PromQueryEditorProps) {
const { app } = props;
switch (app) {
case CoreApp.CloudAlerting:
return <PromQueryEditorForAlerting {...props} />;
default:
return <PromQueryEditor {...props} />;
}
}
export default memo(PromQueryEditorByApp);

@ -0,0 +1,25 @@
import React from 'react';
import PromQueryField from './PromQueryField';
import { PromQueryEditorProps } from './types';
export function PromQueryEditorForAlerting(props: PromQueryEditorProps) {
const { datasource, query, range, data, onChange, onRunQuery } = props;
return (
<PromQueryField
datasource={datasource}
query={query}
onRunQuery={onRunQuery}
onChange={onChange}
history={[]}
range={range}
data={data}
placeholder="Enter a PromQL query"
data-testid={testIds.editor}
/>
);
}
export const testIds = {
editor: 'prom-editor-cloud-alerting',
};

@ -77,6 +77,8 @@ export function willApplySuggestion(suggestion: string, { typeaheadContext, type
interface PromQueryFieldProps extends ExploreQueryFieldProps<PrometheusDatasource, PromQuery, PromOptions> {
history: Array<HistoryItem<PromQuery>>;
ExtraFieldElement?: ReactNode;
placeholder?: string;
'data-testid'?: string;
}
interface PromQueryFieldState {
@ -271,7 +273,9 @@ class PromQueryField extends React.PureComponent<PromQueryFieldProps, PromQueryF
datasource: { languageProvider },
query,
ExtraFieldElement,
placeholder = 'Enter a PromQL query (run with Shift+Enter)',
} = this.props;
const { labelBrowserVisible, syntaxLoaded, hint } = this.state;
const cleanText = languageProvider ? languageProvider.cleanText : undefined;
const hasMetrics = languageProvider.metrics.length > 0;
@ -280,7 +284,10 @@ class PromQueryField extends React.PureComponent<PromQueryFieldProps, PromQueryF
return (
<>
<div className="gf-form-inline gf-form-inline--xs-view-flex-column flex-grow-1">
<div
className="gf-form-inline gf-form-inline--xs-view-flex-column flex-grow-1"
data-testid={this.props['data-testid']}
>
<button
className="gf-form-label query-keyword pointer"
onClick={this.onClickChooserButton}
@ -300,7 +307,7 @@ class PromQueryField extends React.PureComponent<PromQueryFieldProps, PromQueryF
onBlur={this.props.onBlur}
onChange={this.onChangeQuery}
onRunQuery={this.props.onRunQuery}
placeholder="Enter a PromQL query (run with Shift+Enter)"
placeholder={placeholder}
portalOrigin="prometheus"
syntaxLoaded={syntaxLoaded}
/>

@ -178,6 +178,7 @@ exports[`Render PromQueryEditor with basic options should render 1`] = `
/>
</div>
}
data-testid="prom-editor"
datasource={
Object {
"createQuery": [MockFunction],

@ -0,0 +1,5 @@
import { QueryEditorProps } from '@grafana/data';
import { PrometheusDatasource } from '../datasource';
import { PromOptions, PromQuery } from '../types';
export type PromQueryEditorProps = QueryEditorProps<PrometheusDatasource, PromQuery, PromOptions>;

@ -1,7 +1,7 @@
import { DataSourcePlugin } from '@grafana/data';
import { ANNOTATION_QUERY_STEP_DEFAULT, PrometheusDatasource } from './datasource';
import { PromQueryEditor } from './components/PromQueryEditor';
import PromQueryEditorByApp from './components/PromQueryEditorByApp';
import PromCheatSheet from './components/PromCheatSheet';
import PromExploreQueryEditor from './components/PromExploreQueryEditor';
@ -13,7 +13,7 @@ class PrometheusAnnotationsQueryCtrl {
}
export const plugin = new DataSourcePlugin(PrometheusDatasource)
.setQueryEditor(PromQueryEditor)
.setQueryEditor(PromQueryEditorByApp)
.setConfigEditor(ConfigEditor)
.setExploreMetricsQueryField(PromExploreQueryEditor)
.setAnnotationQueryCtrl(PrometheusAnnotationsQueryCtrl)

@ -50,11 +50,9 @@ export class TempoQueryField extends React.PureComponent<Props, State> {
};
render() {
const { query, onChange, range } = this.props;
const { query, onChange } = this.props;
const { linkedDatasource } = this.state;
const absoluteTimeRange = { from: range!.from!.valueOf(), to: range!.to!.valueOf() }; // Range here is never optional
return (
<>
<InlineFieldRow>
@ -87,7 +85,6 @@ export class TempoQueryField extends React.PureComponent<Props, State> {
onRunQuery={this.onRunLinkedQuery}
query={this.linkedQuery as any}
history={[]}
absoluteRange={absoluteTimeRange}
/>
</>
)}

Loading…
Cancel
Save