Elasticsearch: Implement schema for query (#62147)

* Elasticsearch: Implement schema for query

* Comment out types I am not sure how to do

* Manually fix typing for PipelineMetricAggregationWithMultipleBucketPaths and BasePipelineMetricAggregation

* Import types to types.ts to have single source of truth

* Cleanup, reorder

* Remove unnecesary Schema.

* Fix test

* Refactor
pull/62604/head
Ivana Huckova 2 years ago committed by GitHub
parent 4a8763d7b6
commit ccfa9a4ef0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 34
      docs/sources/developers/kinds/composable/elasticsearchdataquery/schema-reference.md
  2. 20
      pkg/kindsys/report.json
  3. 1290
      pkg/tsdb/elasticsearch/kinds/dataquery/types_dataquery_gen.go
  4. 431
      public/app/plugins/datasource/elasticsearch/dataquery.cue
  5. 374
      public/app/plugins/datasource/elasticsearch/dataquery.gen.ts
  6. 4
      public/app/plugins/datasource/elasticsearch/datasource.test.ts
  7. 107
      public/app/plugins/datasource/elasticsearch/types.ts

@ -0,0 +1,34 @@
---
keywords:
- grafana
- schema
title: ElasticsearchDataQuery kind
---
> Both documentation generation and kinds schemas are in active development and subject to change without prior notice.
# ElasticsearchDataQuery kind
## Maturity: merged
## Version: 0.0
## Properties
| Property | Type | Required | Description |
|--------------|-------------------------------------------|----------|-------------|
| `alias` | string | No | |
| `bucketAggs` | [BucketAggregation](#bucketaggregation)[] | No | |
| `metrics` | [MetricAggregation](#metricaggregation)[] | No | |
| `query` | string | No | |
| `timeField` | string | No | |
## BucketAggregation
| Property | Type | Required | Description |
|----------|------|----------|-------------|
## MetricAggregation
| Property | Type | Required | Description |
|----------|------|----------|-------------|

@ -426,7 +426,9 @@
}, },
"elasticsearchdataquery": { "elasticsearchdataquery": {
"category": "composable", "category": "composable",
"codeowners": [], "codeowners": [
"grafana/observability-logs"
],
"currentVersion": [ "currentVersion": [
0, 0,
0 0
@ -434,13 +436,13 @@
"grafanaMaturityCount": 0, "grafanaMaturityCount": 0,
"lineageIsGroup": false, "lineageIsGroup": false,
"links": { "links": {
"docs": "n/a", "docs": "https://grafana.com/docs/grafana/next/developers/kinds/composable/elasticsearchdataquery/schema-reference",
"go": "n/a", "go": "https://github.com/grafana/grafana/tree/main/pkg/tsdb/elasticsearch/kinds/dataquery/types_dataquery_gen.go",
"schema": "n/a", "schema": "https://github.com/grafana/grafana/tree/main/public/app/plugins/datasource/elasticsearch/dataquery.cue",
"ts": "n/a" "ts": "https://github.com/grafana/grafana/tree/main/public/app/plugins/datasource/elasticsearch/dataquery.gen.ts"
}, },
"machineName": "elasticsearchdataquery", "machineName": "elasticsearchdataquery",
"maturity": "planned", "maturity": "merged",
"name": "ElasticsearchDataQuery", "name": "ElasticsearchDataQuery",
"pluralMachineName": "elasticsearchdataquerys", "pluralMachineName": "elasticsearchdataquerys",
"pluralName": "ElasticsearchDataQuerys", "pluralName": "ElasticsearchDataQuerys",
@ -2002,13 +2004,14 @@
"name": "merged", "name": "merged",
"items": [ "items": [
"alertgroupspanelcfg", "alertgroupspanelcfg",
"elasticsearchdataquery",
"playlist", "playlist",
"preferences", "preferences",
"publicdashboard", "publicdashboard",
"serviceaccount", "serviceaccount",
"team" "team"
], ],
"count": 6 "count": 7
}, },
"planned": { "planned": {
"name": "planned", "name": "planned",
@ -2025,7 +2028,6 @@
"dashboarddatasourcecfg", "dashboarddatasourcecfg",
"datasource", "datasource",
"debugpanelcfg", "debugpanelcfg",
"elasticsearchdataquery",
"elasticsearchdatasourcecfg", "elasticsearchdatasourcecfg",
"flamegraphpanelcfg", "flamegraphpanelcfg",
"folder", "folder",
@ -2068,7 +2070,7 @@
"zipkindataquery", "zipkindataquery",
"zipkindatasourcecfg" "zipkindatasourcecfg"
], ],
"count": 54 "count": 53
}, },
"stable": { "stable": {
"name": "stable", "name": "stable",

@ -0,0 +1,431 @@
// Copyright 2023 Grafana Labs
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package grafanaplugin
import (
"github.com/grafana/grafana/packages/grafana-schema/src/common"
"github.com/grafana/grafana/pkg/plugins/pfs"
)
// This file (with its sibling .cue files) implements pfs.GrafanaPlugin
pfs.GrafanaPlugin
composableKinds: DataQuery: {
maturity: "merged"
lineage: {
seqs: [
{
schemas: [
{
common.DataQuery
alias?: string
query?: string
timeField?: string
bucketAggs?: [...#BucketAggregation]
metrics?: [...#MetricAggregation]
#BucketAggregation: #DateHistogram | #Histogram | #Terms | #Filters | #GeoHashGrid | #Nested @cuetsy(kind="type")
#MetricAggregation: #Count | #PipelineMetricAggregation | #MetricAggregationWithSettings @cuetsy(kind="type")
#BucketAggregationType: "terms" | "filters" | "geohash_grid" | "date_histogram" | "histogram" | "nested" @cuetsy(kind="type")
#BaseBucketAggregation: {
id: string
type: #BucketAggregationType
settings?: {...}
} @cuetsy(kind="interface")
#BucketAggregationWithField: {
#BaseBucketAggregation
field?: string
} @cuetsy(kind="interface")
#DateHistogram: {
#BucketAggregationWithField
type: #BucketAggregationType & "date_histogram"
settings?: #DateHistogramSettings
} @cuetsy(kind="interface")
#DateHistogramSettings: {
interval?: string
min_doc_count?: string
trimEdges?: string
offset?: string
timeZone?: string
} @cuetsy(kind="interface")
#Histogram: {
#BucketAggregationWithField
type: #BucketAggregationType & "histogram"
settings?: #HistogramSettings
} @cuetsy(kind="interface")
#HistogramSettings: {
interval?: string
min_doc_count?: string
} @cuetsy(kind="interface")
#TermsOrder: "desc" | "asc" @cuetsy(kind="type")
#Nested: {
#BucketAggregationWithField
type: #BucketAggregationType & "nested"
settings?: {}
} @cuetsy(kind="interface")
#Terms: {
#BucketAggregationWithField
type: #BucketAggregationType & "terms"
settings?: #TermsSettings
} @cuetsy(kind="interface")
#TermsSettings: {
order?: #TermsOrder
size?: string
min_doc_count?: string
orderBy?: string
missing?: string
} @cuetsy(kind="interface")
#Filters: {
#BaseBucketAggregation
type: #BucketAggregationType & "filters"
settings?: #FiltersSettings
} @cuetsy(kind="interface")
#Filter: {
query: string
label: string
} @cuetsy(kind="type")
#FiltersSettings: {
filters?: [...#Filter]
} @cuetsy(kind="interface")
#GeoHashGrid: {
#BucketAggregationWithField
type: #BucketAggregationType & "geohash_grid"
settings?: #GeoHashGridSettings
} @cuetsy(kind="interface")
#GeoHashGridSettings: {
precision?: string
} @cuetsy(kind="interface")
#PipelineMetricAggregationType: "moving_avg" | "moving_fn" | "derivative" | "serial_diff" | "cumulative_sum" | "bucket_script" @cuetsy(kind="type")
#MetricAggregationType: "count" | "avg" | "sum" | "min" | "max" | "extended_stats" | "percentiles" | "cardinality" | "raw_document" | "raw_data" | "logs" | "rate" | "top_metrics" | #PipelineMetricAggregationType @cuetsy(kind="type")
#BaseMetricAggregation: {
type: #MetricAggregationType
id: string
hide?: bool
} @cuetsy(kind="interface")
#PipelineVariable: {
name: string
pipelineAgg: string
} @cuetsy(kind="interface")
#MetricAggregationWithField: {
#BaseMetricAggregation
field?: string
} @cuetsy(kind="interface")
#MetricAggregationWithMissingSupport: {
#BaseMetricAggregation
settings?: {
missing?: string
}
} @cuetsy(kind="interface")
#InlineScript: string | {inline?: string} @cuetsy(kind="type")
#MetricAggregationWithInlineScript: {
#BaseMetricAggregation
settings?: {
script?: #InlineScript
}
} @cuetsy(kind="interface")
#Count: {
#BaseMetricAggregation
type: #MetricAggregationType & "count"
} @cuetsy(kind="interface")
#Average: {
#MetricAggregationWithField
#MetricAggregationWithMissingSupport
#MetricAggregationWithInlineScript
type: #MetricAggregationType & "avg"
settings?: {
script?: #InlineScript
missing?: string
}
} @cuetsy(kind="interface")
#Sum: {
#MetricAggregationWithField
#MetricAggregationWithInlineScript
type: #MetricAggregationType & "sum"
settings?: {
script?: #InlineScript
missing?: string
}
} @cuetsy(kind="interface")
#Max: {
#MetricAggregationWithField
#MetricAggregationWithInlineScript
type: #MetricAggregationType & "max"
settings?: {
script?: #InlineScript
missing?: string
}
} @cuetsy(kind="interface")
#Min: {
#MetricAggregationWithField
#MetricAggregationWithInlineScript
type: #MetricAggregationType & "min"
settings?: {
script?: #InlineScript
missing?: string
}
} @cuetsy(kind="interface")
#ExtendedStatMetaType: "avg" | "min" | "max" | "sum" | "count" | "std_deviation" | "std_deviation_bounds_upper" | "std_deviation_bounds_lower" @cuetsy(kind="type")
#ExtendedStat: {
label: string
value: #ExtendedStatMetaType
} @cuetsy(kind="interface")
#ExtendedStats: {
#MetricAggregationWithField
#MetricAggregationWithInlineScript
type: #MetricAggregationType & "extended_stats"
settings?: {
script?: #InlineScript
missing?: string
sigma?: string
}
meta?: [#ExtendedStatMetaType]: bool
} @cuetsy(kind="interface")
#Percentiles: {
#MetricAggregationWithField
#MetricAggregationWithInlineScript
type: #MetricAggregationType & "percentiles"
settings?: {
script?: #InlineScript
missing?: string
percents?: [...string]
}
} @cuetsy(kind="interface")
#UniqueCount: {
#MetricAggregationWithField
type: #MetricAggregationType & "cardinality"
settings?: {
precision_threshold?: string
missing?: string
}
} @cuetsy(kind="interface")
#RawDocument: {
#BaseMetricAggregation
type: #MetricAggregationType & "raw_document"
settings?: {
size?: string
}
} @cuetsy(kind="interface")
#RawData: {
#BaseMetricAggregation
type: #MetricAggregationType & "raw_data"
settings?: {
size?: string
}
} @cuetsy(kind="interface")
#Logs: {
#BaseMetricAggregation
type: #MetricAggregationType & "logs"
settings?: {
limit?: string
}
} @cuetsy(kind="interface")
#Rate: {
#MetricAggregationWithField
type: #MetricAggregationType & "rate"
settings?: {
unit?: string
mode?: string
}
} @cuetsy(kind="interface")
#BasePipelineMetricAggregation: {
#MetricAggregationWithField
//TODO: Type is temporarily commented out as it causes a type error in the generated code. In the meantime, we decided to manually extend the type in types.ts.
//type: #PipelineMetricAggregationType
pipelineAgg?: string
} @cuetsy(kind="interface")
#PipelineMetricAggregationWithMultipleBucketPaths: {
#BaseMetricAggregation
//TODO: Type is temporarily commented out as it causes a type error in the generated code. In the meantime, we decided to manually extend the type in types.ts.
//type: #PipelineMetricAggregationType
pipelineVariables?: [...#PipelineVariable]
} @cuetsy(kind="interface")
#MovingAverageModel: "simple" | "linear" | "ewma" | "holt" | "holt_winters" @cuetsy(kind="type")
#MovingAverageModelOption: {
label: string
value: #MovingAverageModel
} @cuetsy(kind="interface")
#BaseMovingAverageModelSettings: {
model: #MovingAverageModel
window: string
predict: string
} @cuetsy(kind="interface")
#MovingAverageSimpleModelSettings: {
#BaseMovingAverageModelSettings
model: #MovingAverageModel & "simple"
} @cuetsy(kind="interface")
#MovingAverageLinearModelSettings: {
#BaseMovingAverageModelSettings
model: #MovingAverageModel & "linear"
} @cuetsy(kind="interface")
#MovingAverageEWMAModelSettings: {
#BaseMovingAverageModelSettings
model: #MovingAverageModel & "ewma"
settings?: {
alpha?: string
}
minimize: bool
} @cuetsy(kind="interface")
#MovingAverageHoltModelSettings: {
#BaseMovingAverageModelSettings
model: #MovingAverageModel & "holt"
settings: {
alpha?: string
beta?: string
}
minimize: bool
} @cuetsy(kind="interface")
#MovingAverageHoltWintersModelSettings: {
#BaseMovingAverageModelSettings
model: #MovingAverageModel & "holt_winters"
settings: {
alpha?: string
beta?: string
gamma?: string
period?: string
pad?: bool
}
minimize: bool
} @cuetsy(kind="interface")
// #MovingAverageModelSettings Not sure how to do this one:
// export type MovingAverageModelSettings<T extends MovingAverageModel = MovingAverageModel> = Partial<
// Extract<
// | MovingAverageSimpleModelSettings
// | MovingAverageLinearModelSettings
// | MovingAverageEWMAModelSettings
// | MovingAverageHoltModelSettings
// | MovingAverageHoltWintersModelSettings,
// { model: T }
// >
// >;
// #MovingAverage's settings are overridden in types.ts
#MovingAverage: {
#BasePipelineMetricAggregation
type: "moving_avg"
settings?: {...}
} @cuetsy(kind="interface")
#MovingFunction: {
#BasePipelineMetricAggregation
type: #PipelineMetricAggregationType & "moving_fn"
settings?: {
window?: string
script?: #InlineScript
shift?: string
}
} @cuetsy(kind="interface")
#Derivative: {
#BasePipelineMetricAggregation
type: #PipelineMetricAggregationType & "derivative"
settings?: {
unit?: string
}
} @cuetsy(kind="interface")
#SerialDiff: {
#BasePipelineMetricAggregation
type: #PipelineMetricAggregationType & "serial_diff"
settings?: {
lag?: string
}
} @cuetsy(kind="interface")
#CumulativeSum: {
#BasePipelineMetricAggregation
type: #PipelineMetricAggregationType & "cumulative_sum"
settings?: {
format?: string
}
} @cuetsy(kind="interface")
#BucketScript: {
#PipelineMetricAggregationWithMultipleBucketPaths
type: #PipelineMetricAggregationType & "bucket_script"
settings?: {
script?: #InlineScript
}
} @cuetsy(kind="interface")
#TopMetrics: {
#BaseMetricAggregation
type: #MetricAggregationType & "top_metrics"
settings?: {
order?: string
orderBy?: string
metrics?: [...string]
}
} @cuetsy(kind="interface")
#PipelineMetricAggregation: #MovingAverage | #Derivative | #CumulativeSum | #BucketScript @cuetsy(kind="type")
#MetricAggregationWithSettings: #BucketScript | #CumulativeSum | #Derivative | #SerialDiff | #RawData | #RawDocument | #UniqueCount | #Percentiles | #ExtendedStats | #Min | #Max | #Sum | #Average | #MovingAverage | #MovingFunction | #Logs | #Rate | #TopMetrics @cuetsy(kind="type")
},
]
},
]
}
}

@ -0,0 +1,374 @@
// Code generated - EDITING IS FUTILE. DO NOT EDIT.
//
// Generated by:
// public/app/plugins/gen.go
// Using jennies:
// TSTypesJenny
// PluginTSTypesJenny
//
// Run 'make gen-cue' from repository root to regenerate.
import * as common from '@grafana/schema';
export const DataQueryModelVersion = Object.freeze([0, 0]);
export type BucketAggregation = (DateHistogram | Histogram | Terms | Filters | GeoHashGrid | Nested);
export type MetricAggregation = (Count | PipelineMetricAggregation | MetricAggregationWithSettings);
export type BucketAggregationType = ('terms' | 'filters' | 'geohash_grid' | 'date_histogram' | 'histogram' | 'nested');
export interface BaseBucketAggregation {
id: string;
settings?: Record<string, unknown>;
type: BucketAggregationType;
}
export interface BucketAggregationWithField extends BaseBucketAggregation {
field?: string;
}
export interface DateHistogram extends BucketAggregationWithField {
type: 'date_histogram';
}
export interface DateHistogramSettings {
interval?: string;
min_doc_count?: string;
offset?: string;
timeZone?: string;
trimEdges?: string;
}
export interface Histogram extends BucketAggregationWithField {
type: 'histogram';
}
export interface HistogramSettings {
interval?: string;
min_doc_count?: string;
}
export type TermsOrder = ('desc' | 'asc');
export interface Nested extends BucketAggregationWithField {
type: 'nested';
}
export interface Terms extends BucketAggregationWithField {
type: 'terms';
}
export interface TermsSettings {
min_doc_count?: string;
missing?: string;
order?: TermsOrder;
orderBy?: string;
size?: string;
}
export interface Filters extends BaseBucketAggregation {
type: 'filters';
}
export type Filter = {
query: string,
label: string,
};
export interface FiltersSettings {
filters?: Array<Filter>;
}
export const defaultFiltersSettings: Partial<FiltersSettings> = {
filters: [],
};
export interface GeoHashGrid extends BucketAggregationWithField {
type: 'geohash_grid';
}
export interface GeoHashGridSettings {
precision?: string;
}
export type PipelineMetricAggregationType = ('moving_avg' | 'moving_fn' | 'derivative' | 'serial_diff' | 'cumulative_sum' | 'bucket_script');
export type MetricAggregationType = ('count' | 'avg' | 'sum' | 'min' | 'max' | 'extended_stats' | 'percentiles' | 'cardinality' | 'raw_document' | 'raw_data' | 'logs' | 'rate' | 'top_metrics' | PipelineMetricAggregationType);
export interface BaseMetricAggregation {
hide?: boolean;
id: string;
type: MetricAggregationType;
}
export interface PipelineVariable {
name: string;
pipelineAgg: string;
}
export interface MetricAggregationWithField extends BaseMetricAggregation {
field?: string;
}
export interface MetricAggregationWithMissingSupport extends BaseMetricAggregation {
settings?: {
missing?: string;
};
}
export type InlineScript = (string | {
inline?: string
});
export interface MetricAggregationWithInlineScript extends BaseMetricAggregation {
settings?: {
script?: InlineScript;
};
}
export interface Count extends BaseMetricAggregation {
type: 'count';
}
export interface Average extends MetricAggregationWithField, MetricAggregationWithMissingSupport, MetricAggregationWithInlineScript {
field?: string;
settings?: {
script?: (InlineScript | InlineScript);
missing?: string;
};
type: 'avg';
}
export interface Sum extends MetricAggregationWithField, MetricAggregationWithInlineScript {
field?: string;
settings?: {
script?: (InlineScript | InlineScript);
missing?: string;
};
type: 'sum';
}
export interface Max extends MetricAggregationWithField, MetricAggregationWithInlineScript {
field?: string;
settings?: {
script?: (InlineScript | InlineScript);
missing?: string;
};
type: 'max';
}
export interface Min extends MetricAggregationWithField, MetricAggregationWithInlineScript {
field?: string;
settings?: {
script?: (InlineScript | InlineScript);
missing?: string;
};
type: 'min';
}
export type ExtendedStatMetaType = ('avg' | 'min' | 'max' | 'sum' | 'count' | 'std_deviation' | 'std_deviation_bounds_upper' | 'std_deviation_bounds_lower');
export interface ExtendedStat {
label: string;
value: ExtendedStatMetaType;
}
export interface ExtendedStats extends MetricAggregationWithField, MetricAggregationWithInlineScript {
field?: string;
meta?: Record<string, unknown>;
settings?: {
script?: (InlineScript | InlineScript);
missing?: string;
sigma?: string;
};
type: 'extended_stats';
}
export interface Percentiles extends MetricAggregationWithField, MetricAggregationWithInlineScript {
field?: string;
settings?: {
script?: (InlineScript | InlineScript);
missing?: string;
percents?: Array<string>;
};
type: 'percentiles';
}
export interface UniqueCount extends MetricAggregationWithField {
settings?: {
precision_threshold?: string;
missing?: string;
};
type: 'cardinality';
}
export interface RawDocument extends BaseMetricAggregation {
settings?: {
size?: string;
};
type: 'raw_document';
}
export interface RawData extends BaseMetricAggregation {
settings?: {
size?: string;
};
type: 'raw_data';
}
export interface Logs extends BaseMetricAggregation {
settings?: {
limit?: string;
};
type: 'logs';
}
export interface Rate extends MetricAggregationWithField {
settings?: {
unit?: string;
mode?: string;
};
type: 'rate';
}
export interface BasePipelineMetricAggregation extends MetricAggregationWithField {
/**
* TODO: Type is temporarily commented out as it causes a type error in the generated code. In the meantime, we decided to manually extend the type in types.ts.
* type: #PipelineMetricAggregationType
*/
pipelineAgg?: string;
}
export interface PipelineMetricAggregationWithMultipleBucketPaths extends BaseMetricAggregation {
/**
* TODO: Type is temporarily commented out as it causes a type error in the generated code. In the meantime, we decided to manually extend the type in types.ts.
* type: #PipelineMetricAggregationType
*/
pipelineVariables?: Array<PipelineVariable>;
}
export const defaultPipelineMetricAggregationWithMultipleBucketPaths: Partial<PipelineMetricAggregationWithMultipleBucketPaths> = {
pipelineVariables: [],
};
export type MovingAverageModel = ('simple' | 'linear' | 'ewma' | 'holt' | 'holt_winters');
export interface MovingAverageModelOption {
label: string;
value: MovingAverageModel;
}
export interface BaseMovingAverageModelSettings {
model: MovingAverageModel;
predict: string;
window: string;
}
export interface MovingAverageSimpleModelSettings extends BaseMovingAverageModelSettings {
model: 'simple';
}
export interface MovingAverageLinearModelSettings extends BaseMovingAverageModelSettings {
model: 'linear';
}
export interface MovingAverageEWMAModelSettings extends BaseMovingAverageModelSettings {
minimize: boolean;
model: 'ewma';
settings?: {
alpha?: string;
};
}
export interface MovingAverageHoltModelSettings extends BaseMovingAverageModelSettings {
minimize: boolean;
model: 'holt';
settings: {
alpha?: string;
beta?: string;
};
}
export interface MovingAverageHoltWintersModelSettings extends BaseMovingAverageModelSettings {
minimize: boolean;
model: 'holt_winters';
settings: {
alpha?: string;
beta?: string;
gamma?: string;
period?: string;
pad?: boolean;
};
}
/**
* #MovingAverage's settings are overridden in types.ts
*/
export interface MovingAverage extends BasePipelineMetricAggregation {
settings?: Record<string, unknown>;
type: 'moving_avg';
}
export interface MovingFunction extends BasePipelineMetricAggregation {
settings?: {
window?: string;
script?: InlineScript;
shift?: string;
};
type: 'moving_fn';
}
export interface Derivative extends BasePipelineMetricAggregation {
settings?: {
unit?: string;
};
type: 'derivative';
}
export interface SerialDiff extends BasePipelineMetricAggregation {
settings?: {
lag?: string;
};
type: 'serial_diff';
}
export interface CumulativeSum extends BasePipelineMetricAggregation {
settings?: {
format?: string;
};
type: 'cumulative_sum';
}
export interface BucketScript extends PipelineMetricAggregationWithMultipleBucketPaths {
settings?: {
script?: InlineScript;
};
type: 'bucket_script';
}
export interface TopMetrics extends BaseMetricAggregation {
settings?: {
order?: string;
orderBy?: string;
metrics?: Array<string>;
};
type: 'top_metrics';
}
export type PipelineMetricAggregation = (MovingAverage | Derivative | CumulativeSum | BucketScript);
export type MetricAggregationWithSettings = (BucketScript | CumulativeSum | Derivative | SerialDiff | RawData | RawDocument | UniqueCount | Percentiles | ExtendedStats | Min | Max | Sum | Average | MovingAverage | MovingFunction | Logs | Rate | TopMetrics);
export interface Elasticsearch extends common.DataQuery {
alias?: string;
bucketAggs?: Array<BucketAggregation>;
metrics?: Array<MetricAggregation>;
query?: string;
timeField?: string;
}
export const defaultElasticsearch: Partial<Elasticsearch> = {
bucketAggs: [],
metrics: [],
};

@ -314,7 +314,7 @@ describe('ElasticDatasource', () => {
database: 'mock-index', database: 'mock-index',
}); });
const query: DataQueryRequest<ElasticsearchQuery> = { const query = {
range: createTimeRange(toUtc([2015, 4, 30, 10]), toUtc([2019, 7, 1, 10])), range: createTimeRange(toUtc([2015, 4, 30, 10]), toUtc([2019, 7, 1, 10])),
targets: [ targets: [
{ {
@ -332,7 +332,7 @@ describe('ElasticDatasource', () => {
timeField: '@timestamp', timeField: '@timestamp',
}, },
], ],
} as DataQueryRequest<ElasticsearchQuery>; } as unknown as DataQueryRequest<ElasticsearchQuery>;
const queryBuilderSpy = jest.spyOn(ds.queryBuilder, 'getLogsQuery'); const queryBuilderSpy = jest.spyOn(ds.queryBuilder, 'getLogsQuery');
let response: DataQueryResponse = { data: [] }; let response: DataQueryResponse = { data: [] };

@ -1,13 +1,102 @@
import { DataQuery, DataSourceJsonData } from '@grafana/data'; import { DataSourceJsonData } from '@grafana/data';
import { import {
BucketAggregation,
BucketAggregationType, BucketAggregationType,
} from './components/QueryEditor/BucketAggregationsEditor/aggregations'; Filter,
import {
MetricAggregation, MetricAggregation,
MetricAggregationType, MetricAggregationType,
} from './components/QueryEditor/MetricAggregationsEditor/aggregations'; MovingAverageEWMAModelSettings,
MovingAverageHoltModelSettings,
MovingAverageHoltWintersModelSettings,
MovingAverageLinearModelSettings,
MovingAverageModel,
MovingAverageSimpleModelSettings,
PipelineMetricAggregationType,
TermsOrder,
BasePipelineMetricAggregation as SchemaBasePipelineMetricAggregation,
PipelineMetricAggregationWithMultipleBucketPaths as SchemaPipelineMetricAggregationWithMultipleBucketPaths,
MovingAverage as SchemaMovingAverage,
Filters as SchemaFilters,
Terms as SchemaTerms,
DateHistogram as SchemaDateHistogram,
Histogram as SchemaHistogram,
GeoHashGrid as SchemaGeoHashGrid,
Nested as SchemaNested,
} from './dataquery.gen';
export * from './dataquery.gen';
export { Elasticsearch as ElasticsearchQuery } from './dataquery.gen';
// Start of temporary overrides because of incorrect type generation in dataquery.gen.ts
export interface BasePipelineMetricAggregation extends SchemaBasePipelineMetricAggregation {
type: PipelineMetricAggregationType;
}
export interface PipelineMetricAggregationWithMultipleBucketPaths
extends SchemaPipelineMetricAggregationWithMultipleBucketPaths {
type: PipelineMetricAggregationType;
}
export type MovingAverageModelSettings<T extends MovingAverageModel = MovingAverageModel> = Partial<
Extract<
| MovingAverageSimpleModelSettings
| MovingAverageLinearModelSettings
| MovingAverageEWMAModelSettings
| MovingAverageHoltModelSettings
| MovingAverageHoltWintersModelSettings,
{ model: T }
>
>;
export interface MovingAverage<T extends MovingAverageModel = MovingAverageModel> extends SchemaMovingAverage {
settings?: MovingAverageModelSettings<T>;
}
export interface Filters extends SchemaFilters {
settings?: {
filters?: Filter[];
};
}
export interface Terms extends SchemaTerms {
settings?: {
min_doc_count?: string;
missing?: string;
order?: TermsOrder;
orderBy?: string;
size?: string;
};
}
export interface DateHistogram extends SchemaDateHistogram {
settings?: {
interval?: string;
min_doc_count?: string;
offset?: string;
timeZone?: string;
trimEdges?: string;
};
}
export interface Histogram extends SchemaHistogram {
settings?: {
interval?: string;
min_doc_count?: string;
};
}
interface GeoHashGrid extends SchemaGeoHashGrid {
settings?: {
precision?: string;
};
}
interface Nested extends SchemaNested {
settings?: {};
}
export type BucketAggregation = DateHistogram | Histogram | Terms | Filters | GeoHashGrid | Nested;
// End of temporary overrides
export type Interval = 'Hourly' | 'Daily' | 'Weekly' | 'Monthly' | 'Yearly'; export type Interval = 'Hourly' | 'Daily' | 'Weekly' | 'Monthly' | 'Yearly';
@ -65,14 +154,6 @@ export interface ElasticsearchAggregation {
hide: boolean; hide: boolean;
} }
export interface ElasticsearchQuery extends DataQuery {
alias?: string;
query?: string;
bucketAggs?: BucketAggregation[];
metrics?: MetricAggregation[];
timeField?: string;
}
export interface TermsQuery { export interface TermsQuery {
query?: string; query?: string;
size?: number; size?: number;

Loading…
Cancel
Save