@grafana/ui/types/datasource.d.ts

Grafana Components Library

import { ComponentType, ComponentClass } from 'react';
import { TimeRange, RawTimeRange, TableData, TimeSeries, DataFrame, LogRowModel, LoadingState } from '@grafana/data';
import { PluginMeta, GrafanaPlugin } from './plugin';
import { PanelData } from './panel';
export interface DataSourcePluginOptionsEditorProps<TOptions> {
    options: TOptions;
    onOptionsChange: (options: TOptions) => void;
}
export declare class DataSourcePlugin<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> extends GrafanaPlugin<DataSourcePluginMeta> {
    DataSourceClass: DataSourceConstructor<DSType, TQuery, TOptions>;
    components: DataSourcePluginComponents<DSType, TQuery, TOptions>;
    constructor(DataSourceClass: DataSourceConstructor<DSType, TQuery, TOptions>);
    setConfigEditor(editor: ComponentType<DataSourcePluginOptionsEditorProps<DataSourceSettings<TOptions>>>): this;
    setConfigCtrl(ConfigCtrl: any): this;
    setQueryCtrl(QueryCtrl: any): this;
    setAnnotationQueryCtrl(AnnotationsQueryCtrl: any): this;
    setQueryEditor(QueryEditor: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>): this;
    setExploreQueryField(ExploreQueryField: ComponentClass<ExploreQueryFieldProps<DSType, TQuery, TOptions>>): this;
    setExploreMetricsQueryField(ExploreQueryField: ComponentClass<ExploreQueryFieldProps<DSType, TQuery, TOptions>>): this;
    setExploreLogsQueryField(ExploreQueryField: ComponentClass<ExploreQueryFieldProps<DSType, TQuery, TOptions>>): this;
    setExploreStartPage(ExploreStartPage: ComponentClass<ExploreStartPageProps>): this;
    setVariableQueryEditor(VariableQueryEditor: any): this;
    setComponentsFromLegacyExports(pluginExports: any): void;
}
export interface DataSourcePluginMeta extends PluginMeta {
    builtIn?: boolean;
    metrics?: boolean;
    logs?: boolean;
    annotations?: boolean;
    alerting?: boolean;
    mixed?: boolean;
    hasQueryHelp?: boolean;
    category?: string;
    queryOptions?: PluginMetaQueryOptions;
    sort?: number;
    streaming?: boolean;
    /**
     * By default, hidden queries are not passed to the datasource
     * Set this to true in plugin.json to have hidden queries passed to the
     * DataSource query method
     */
    hiddenQueries?: boolean;
}
interface PluginMetaQueryOptions {
    cacheTimeout?: boolean;
    maxDataPoints?: boolean;
    minInterval?: boolean;
}
export interface DataSourcePluginComponents<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> {
    QueryCtrl?: any;
    AnnotationsQueryCtrl?: any;
    VariableQueryEditor?: any;
    QueryEditor?: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>;
    ExploreQueryField?: ComponentClass<ExploreQueryFieldProps<DSType, TQuery, TOptions>>;
    ExploreMetricsQueryField?: ComponentClass<ExploreQueryFieldProps<DSType, TQuery, TOptions>>;
    ExploreLogsQueryField?: ComponentClass<ExploreQueryFieldProps<DSType, TQuery, TOptions>>;
    ExploreStartPage?: ComponentClass<ExploreStartPageProps>;
    ConfigEditor?: ComponentType<DataSourcePluginOptionsEditorProps<DataSourceSettings<TOptions>>>;
}
export interface DataSourceConstructor<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> {
    new (instanceSettings: DataSourceInstanceSettings<TOptions>, ...args: any[]): DSType;
}
/**
 * The main data source abstraction interface, represents an instance of a data source
 */
export declare abstract class DataSourceApi<TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> {
    /**
     *  Set in constructor
     */
    readonly name: string;
    /**
     *  Set in constructor
     */
    readonly id: number;
    /**
     *  min interval range
     */
    interval?: string;
    constructor(instanceSettings: DataSourceInstanceSettings<TOptions>);
    /**
     * Imports queries from a different datasource
     */
    importQueries?(queries: TQuery[], originMeta: PluginMeta): Promise<TQuery[]>;
    /**
     * Initializes a datasource after instantiation
     */
    init?: () => void;
    /**
     * Main metrics / data query action
     */
    abstract query(options: DataQueryRequest<TQuery>, observer?: DataStreamObserver): Promise<DataQueryResponse>;
    /**
     * Test & verify datasource settings & connection details
     */
    abstract testDatasource(): Promise<any>;
    /**
     *  Get hints for query improvements
     */
    getQueryHints?(query: TQuery, results: any[], ...rest: any): QueryHint[];
    /**
     * Convert a query to a simple text string
     */
    getQueryDisplayText?(query: TQuery): string;
    /**
     * Retrieve context for a given log row
     */
    getLogRowContext?: <TContextQueryOptions extends {}>(row: LogRowModel, options?: TContextQueryOptions) => Promise<DataQueryResponse>;
    /**
     * Variable query action.
     */
    metricFindQuery?(query: any, options?: any): Promise<MetricFindValue[]>;
    /**
     * Get tag keys for adhoc filters
     */
    getTagKeys?(options: any): Promise<MetricFindValue[]>;
    /**
     * Get tag values for adhoc filters
     */
    getTagValues?(options: any): Promise<MetricFindValue[]>;
    /**
     * Set after constructor call, as the data source instance is the most common thing to pass around
     * we attach the components to this instance for easy access
     */
    components?: DataSourcePluginComponents<DataSourceApi<TQuery, TOptions>, TQuery, TOptions>;
    /**
     * static information about the datasource
     */
    meta?: DataSourcePluginMeta;
    /**
     * Used by alerting to check if query contains template variables
     */
    targetContainsTemplate?(query: TQuery): boolean;
    /**
     * Used in explore
     */
    modifyQuery?(query: TQuery, action: QueryFixAction): TQuery;
    /**
     * Used in explore
     */
    getHighlighterExpression?(query: TQuery): string[];
    /**
     * Used in explore
     */
    languageProvider?: any;
}
export interface QueryEditorProps<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> {
    datasource: DSType;
    query: TQuery;
    onRunQuery: () => void;
    onChange: (value: TQuery) => void;
    panelData: PanelData;
    queryResponse?: PanelData;
}
export declare enum DataSourceStatus {
    Connected = 0,
    Disconnected = 1
}
export interface ExploreQueryFieldProps<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> extends QueryEditorProps<DSType, TQuery, TOptions> {
    datasourceStatus: DataSourceStatus;
    history: any[];
    onHint?: (action: QueryFixAction) => void;
}
export interface ExploreStartPageProps {
    onClickExample: (query: DataQuery) => void;
}
/**
 * Starting in v6.2 DataFrame can represent both TimeSeries and TableData
 */
export declare type LegacyResponseData = TimeSeries | TableData | any;
export declare type DataQueryResponseData = DataFrame | LegacyResponseData;
export declare type DataStreamObserver = (event: DataStreamState) => void;
export interface DataStreamState {
    /**
     * when Done or Error no more events will be processed
     */
    state: LoadingState;
    /**
     * Consistent key across events.
     */
    key: string;
    /**
     * The stream request.  The properties of this request will be examined
     * to determine if the stream matches the original query.  If not, it
     * will be unsubscribed.
     */
    request: DataQueryRequest;
    /**
     * Series data may not be known yet
     */
    series?: DataFrame[];
    /**
     * Error in stream (but may still be running)
     */
    error?: DataQueryError;
    /**
     * Optionally return only the rows that changed in this event
     */
    delta?: DataFrame[];
    /**
     * Stop listening to this stream
     */
    unsubscribe: () => void;
}
export interface DataQueryResponse {
    data: DataQueryResponseData[];
}
export interface DataQuery {
    /**
     * A - Z
     */
    refId: string;
    /**
     * true if query is disabled (ie not executed / sent to TSDB)
     */
    hide?: boolean;
    /**
     * Unique, guid like, string used in explore mode
     */
    key?: string;
    /**
     * For mixed data sources the selected datasource is on the query level.
     * For non mixed scenarios this is undefined.
     */
    datasource?: string | null;
    metric?: any;
}
export interface DataQueryError {
    data?: {
        message?: string;
        error?: string;
    };
    message?: string;
    status?: string;
    statusText?: string;
    refId?: string;
}
export interface ScopedVar {
    text: any;
    value: any;
    [key: string]: any;
}
export interface ScopedVars {
    [key: string]: ScopedVar;
}
export interface DataQueryRequest<TQuery extends DataQuery = DataQuery> {
    requestId: string;
    timezone: string;
    range: TimeRange;
    rangeRaw?: RawTimeRange;
    timeInfo?: string;
    targets: TQuery[];
    panelId: number;
    dashboardId: number;
    cacheTimeout?: string;
    interval: string;
    intervalMs: number;
    maxDataPoints: number;
    scopedVars: ScopedVars;
    startTime: number;
    endTime?: number;
}
export interface QueryFix {
    type: string;
    label: string;
    action?: QueryFixAction;
}
export interface QueryFixAction {
    type: string;
    query?: string;
    preventSubmit?: boolean;
}
export interface QueryHint {
    type: string;
    label: string;
    fix?: QueryFix;
}
export interface MetricFindValue {
    text: string;
}
export interface DataSourceJsonData {
    authType?: string;
    defaultRegion?: string;
}
/**
 * Data Source instance edit model.  This is returned from:
 *  /api/datasources
 */
export interface DataSourceSettings<T extends DataSourceJsonData = DataSourceJsonData, S = {}> {
    id: number;
    orgId: number;
    name: string;
    typeLogoUrl: string;
    type: string;
    access: string;
    url: string;
    password: string;
    user: string;
    database: string;
    basicAuth: boolean;
    basicAuthPassword: string;
    basicAuthUser: string;
    isDefault: boolean;
    jsonData: T;
    secureJsonData?: S;
    readOnly: boolean;
    withCredentials: boolean;
}
/**
 * Frontend settings model that is passed to Datasource constructor. This differs a bit from the model above
 * as this data model is available to every user who has access to a data source (Viewers+).  This is loaded
 * in bootData (on page load), or from: /api/frontend/settings
 */
export interface DataSourceInstanceSettings<T extends DataSourceJsonData = DataSourceJsonData> {
    id: number;
    type: string;
    name: string;
    meta: DataSourcePluginMeta;
    url?: string;
    jsonData: T;
    username?: string;
    password?: string;
    database?: string;
    /**
     * This is the full Authorization header if basic auth is ennabled.
     * Only available here when access is Browser (direct), when acess is Server (proxy)
     * The basic auth header, username & password is never exposted to browser/Frontend
     * so this will be emtpy then.
     */
    basicAuth?: string;
    withCredentials?: boolean;
}
export interface DataSourceSelectItem {
    name: string;
    value: string | null;
    meta: DataSourcePluginMeta;
    sort: string;
}
export {};