Annotations: Deprecate AnnotationsSrv (#39631)

This commit is contained in:
Hugo Häggmark 2021-09-27 15:23:54 +02:00 committed by GitHub
parent 24479ff6b0
commit 80c55ffc83
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

View File

@ -1,191 +1,98 @@
import { cloneDeep, flattenDeep } from 'lodash';
import { lastValueFrom, Observable, of } from 'rxjs';
import { cloneDeep } from 'lodash';
import { Observable, of } from 'rxjs';
import { map, mergeMap } from 'rxjs/operators';
import {
AnnotationEvent,
AppEvents,
CoreApp,
DataQueryRequest,
DataSourceApi,
deprecationWarning,
rangeUtil,
ScopedVars,
} from '@grafana/data';
import { getBackendSrv, getDataSourceSrv } from '@grafana/runtime';
import coreModule from 'app/core/core_module';
import { dedupAnnotations } from './events_processing';
import { DashboardModel } from '../dashboard/state';
import { appEvents } from 'app/core/core';
import { getTimeSrv } from '../dashboard/services/TimeSrv';
import { AnnotationQueryOptions, AnnotationQueryResponse } from './types';
import { standardAnnotationSupport } from './standardAnnotationSupport';
import { runRequest } from '../query/state/runRequest';
import { RefreshEvent } from 'app/types/events';
import { deleteAnnotation, saveAnnotation, updateAnnotation } from './api';
let counter = 100;
function getNextRequestId() {
return 'AQ' + counter++;
}
/**
* @deprecated AnnotationsSrv is deprecated in favor of DashboardQueryRunner
*/
export class AnnotationsSrv {
globalAnnotationsPromise: any;
alertStatesPromise: any;
datasourcePromises: any;
/**
* @deprecated init is deprecated in favor of DashboardQueryRunner.run
*/
init(dashboard: DashboardModel) {
// always clearPromiseCaches when loading new dashboard
this.clearPromiseCaches();
// clear promises on refresh events
dashboard.events.subscribe(RefreshEvent, this.clearPromiseCaches.bind(this));
deprecationWarning('annotations_srv.ts', 'init', 'DashboardQueryRunner.run');
}
/**
* @deprecated clearPromiseCaches is deprecated
*/
clearPromiseCaches() {
this.globalAnnotationsPromise = null;
this.alertStatesPromise = null;
this.datasourcePromises = null;
deprecationWarning('annotations_srv.ts', 'clearPromiseCaches', 'DashboardQueryRunner');
}
/**
* @deprecated getAnnotations is deprecated in favor of DashboardQueryRunner.getResult
*/
getAnnotations(options: AnnotationQueryOptions) {
return Promise.all([this.getGlobalAnnotations(options), this.getAlertStates(options)])
.then((results) => {
// combine the annotations and flatten results
let annotations: AnnotationEvent[] = flattenDeep(results[0]);
// when in edit mode we need to use this function to get the saved ID
let panelFilterId = options.panel.getSavedId();
// filter out annotations that do not belong to requesting panel
annotations = annotations.filter((item) => {
// if event has panel ID and query is of type dashboard then panel and requesting panel ID must match
if (item.panelId && item.source.type === 'dashboard') {
return item.panelId === panelFilterId;
}
return true;
});
annotations = dedupAnnotations(annotations);
// look for alert state for this panel
const alertState: any = results[1].find((res: any) => res.panelId === panelFilterId);
return {
annotations: annotations,
alertState: alertState,
};
})
.catch((err) => {
if (err.cancelled) {
return [];
}
if (!err.message && err.data && err.data.message) {
err.message = err.data.message;
}
console.error('AnnotationSrv.query error', err);
appEvents.emit(AppEvents.alertError, ['Annotation Query Failed', err.message || err]);
return [];
});
deprecationWarning('annotations_srv.ts', 'getAnnotations', 'DashboardQueryRunner.getResult');
return Promise.resolve({ annotations: [], alertState: undefined });
}
/**
* @deprecated getAlertStates is deprecated in favor of DashboardQueryRunner.getResult
*/
getAlertStates(options: any) {
if (!options.dashboard.id) {
return Promise.resolve([]);
}
// ignore if no alerts
if (options.panel && !options.panel.alert) {
return Promise.resolve([]);
}
if (options.range.raw.to !== 'now') {
return Promise.resolve([]);
}
if (this.alertStatesPromise) {
return this.alertStatesPromise;
}
this.alertStatesPromise = getBackendSrv().get(
'/api/alerts/states-for-dashboard',
{
dashboardId: options.dashboard.id,
},
`get-alert-states-${options.dashboard.id}`
);
return this.alertStatesPromise;
deprecationWarning('annotations_srv.ts', 'getAlertStates', 'DashboardQueryRunner.getResult');
return Promise.resolve(undefined);
}
/**
* @deprecated getGlobalAnnotations is deprecated in favor of DashboardQueryRunner.getResult
*/
getGlobalAnnotations(options: AnnotationQueryOptions) {
const dashboard = options.dashboard;
if (this.globalAnnotationsPromise) {
return this.globalAnnotationsPromise;
}
const range = getTimeSrv().timeRange();
const promises = [];
const dsPromises = [];
for (const annotation of dashboard.annotations.list) {
if (!annotation.enable) {
continue;
}
if (annotation.snapshotData) {
return this.translateQueryResult(annotation, annotation.snapshotData);
}
const datasourcePromise = getDataSourceSrv().get(annotation.datasource);
dsPromises.push(datasourcePromise);
promises.push(
datasourcePromise
.then((datasource: DataSourceApi) => {
// Use the legacy annotationQuery unless annotation support is explicitly defined
if (datasource.annotationQuery && !datasource.annotations) {
return datasource.annotationQuery({
range,
rangeRaw: range.raw,
annotation: annotation,
dashboard: dashboard,
});
}
// Note: future annotation lifecycle will use observables directly
return lastValueFrom(executeAnnotationQuery(options, datasource, annotation)).then((res) => {
return res.events ?? [];
});
})
.then((results) => {
// store response in annotation object if this is a snapshot call
if (dashboard.snapshot) {
annotation.snapshotData = cloneDeep(results);
}
// translate result
return this.translateQueryResult(annotation, results);
})
);
}
this.datasourcePromises = Promise.all(dsPromises);
this.globalAnnotationsPromise = Promise.all(promises);
return this.globalAnnotationsPromise;
deprecationWarning('annotations_srv.ts', 'getGlobalAnnotations', 'DashboardQueryRunner.getResult');
return Promise.resolve([]);
}
/**
* @deprecated saveAnnotationEvent is deprecated
*/
saveAnnotationEvent(annotation: AnnotationEvent) {
this.globalAnnotationsPromise = null;
deprecationWarning('annotations_srv.ts', 'saveAnnotationEvent', 'api/saveAnnotation');
return saveAnnotation(annotation);
}
/**
* @deprecated updateAnnotationEvent is deprecated
*/
updateAnnotationEvent(annotation: AnnotationEvent) {
this.globalAnnotationsPromise = null;
deprecationWarning('annotations_srv.ts', 'updateAnnotationEvent', 'api/updateAnnotation');
return updateAnnotation(annotation);
}
/**
* @deprecated deleteAnnotationEvent is deprecated
*/
deleteAnnotationEvent(annotation: AnnotationEvent) {
this.globalAnnotationsPromise = null;
deprecationWarning('annotations_srv.ts', 'deleteAnnotationEvent', 'api/deleteAnnotation');
return deleteAnnotation(annotation);
}
/**
* @deprecated translateQueryResult is deprecated in favor of DashboardQueryRunner/utils/translateQueryResult
*/
translateQueryResult(annotation: any, results: any) {
deprecationWarning('annotations_srv.ts', 'translateQueryResult', 'DashboardQueryRunner/utils/translateQueryResult');
// if annotation has snapshotData
// make clone and remove it
if (annotation.snapshotData) {