diff --git a/assets/kube-burner-report-mode/panels.libsonnet b/assets/kube-burner-report-mode/panels.libsonnet new file mode 100644 index 0000000..a1d5c11 --- /dev/null +++ b/assets/kube-burner-report-mode/panels.libsonnet @@ -0,0 +1,533 @@ +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; + +{ + table: { + local table = g.panel.table, + local options = table.options, + + base(title, unit, targets, gridPos): + table.new(title) + + table.datasource.withType('elasticsearch') + + table.datasource.withUid('$Datasource') + + table.standardOptions.withUnit(unit) + + table.queryOptions.withTargets(targets) + + table.gridPos.withX(gridPos.x) + + table.gridPos.withY(gridPos.y) + + table.gridPos.withH(gridPos.h) + + table.gridPos.withW(gridPos.w), + + withPagination(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + options.footer.TableFooterOptions.withEnablePagination(true), + + withBenchmarkOverview(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + table.queryOptions.withTransformations([ + { + "id": "organize", + "options": { + "excludeByName": { + "_id": true, + "_index": true, + "_type": true, + "benchmark": false, + "clustertype": true, + "endDate": true, + "end_date": true, + "highlight": true, + "jobConfig.cleanup": true, + "jobConfig.errorOnVerify": true, + "jobConfig.jobIterationDelay": true, + "jobConfig.jobIterations": false, + "jobConfig.jobPause": true, + "jobConfig.maxWaitTimeout": true, + "jobConfig.namespace": true, + "jobConfig.namespaced": true, + "jobConfig.namespacedIterations": false, + "jobConfig.objects": true, + "jobConfig.preLoadPeriod": true, + "jobConfig.verifyObjects": true, + "jobConfig.waitFor": true, + "jobConfig.waitForDeletion": true, + "jobConfig.waitWhenFinished": true, + "k8sVersion": true, + "metricName": true, + "ocp_version": true, + "platform": false, + "sdn_type": false, + "sort": true, + "timestamp": true, + "total_nodes": false, + "uuid": false, + "workload": true, + "workload_nodes_count": true, + "workload_nodes_type": true + }, + "indexByName": { + "_id": 1, + "_index": 2, + "_type": 3, + "benchmark": 5, + "clusterName": 8, + "endDate": 9, + "highlight": 6, + "infraNodesCount": 20, + "infraNodesType": 21, + "k8sVersion": 10, + "masterNodesType": 16, + "metricName": 13, + "ocpVersion": 11, + "passed": 15, + "platform": 12, + "sdnType": 14, + "sort": 7, + "timestamp": 0, + "totalNodes": 17, + "uuid": 4, + "workerNodesCount": 18, + "workerNodesType": 19 + }, + "renameByName": { + "_type": "", + "clusterName": "Cluster", + "elapsedTime": "Elapsed time", + "endDate": "", + "infraNodesCount": "infra count", + "infraNodesType": "infra type", + "infra_nodes_count": "Infra nodes", + "infra_nodes_type": "Infra flavor", + "jobConfig.burst": "Burst", + "jobConfig.cleanup": "", + "jobConfig.errorOnVerify": "errorOnVerify", + "jobConfig.jobIterationDelay": "jobIterationDelay", + "jobConfig.jobIterations": "Iterations", + "jobConfig.jobPause": "jobPause", + "jobConfig.jobType": "Job Type", + "jobConfig.maxWaitTimeout": "maxWaitTImeout", + "jobConfig.name": "Name", + "jobConfig.namespace": "namespacePrefix", + "jobConfig.namespaced": "", + "jobConfig.namespacedIterations": "Namespaced iterations", + "jobConfig.objects": "", + "jobConfig.podWait": "podWait", + "jobConfig.preLoadImages": "Preload Images", + "jobConfig.preLoadPeriod": "", + "jobConfig.qps": "QPS", + "jobConfig.verifyObjects": "", + "k8sVersion": "k8s version", + "k8s_version": "k8s version", + "masterNodesType": "master type", + "master_nodes_count": "Master nodes", + "master_nodes_type": "Masters flavor", + "metricName": "", + "ocpVersion": "OCP version", + "passed": "Passed", + "platform": "Platform", + "result": "Result", + "sdnType": "SDN", + "sdn_type": "SDN", + "timestamp": "", + "totalNodes": "total nodes", + "total_nodes": "Total nodes", + "uuid": "UUID", + "workerNodesCount": "worker count", + "workerNodesType": "worker type", + "worker_nodes_count": "Worker nodes", + "worker_nodes_type": "Workers flavor", + "workload": "", + "workload_nodes_count": "Workload nodes", + "workload_nodes_type": "Workload flavor" + } + } + } + ]) + + table.standardOptions.withOverrides([ + { + "matcher": { + "id": "byName", + "options": "passed" + }, + "properties": [ + { + "id": "custom.cellOptions", + "value": { + "mode": "basic", + "type": "color-background" + } + } + ] + } + ]) + + table.standardOptions.withMappings([ + { + "options": { + "passed": { + "color": "green", + "index": 0 + } + }, + "type": "value" + } + ]) + + table.standardOptions.thresholds.withSteps([ + { + "color": "green", + "value": null + } + ]), + + withGarbageCollection(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + table.queryOptions.withTransformations([ + { + "id": "organize", + "options": { + "excludeByName": { + "_id": true, + "_index": true, + "_type": true, + "highlight": true, + "jobConfig.churnDelay": true, + "jobConfig.churnDuration": true, + "jobConfig.churnPercent": true, + "jobConfig.cleanup": true, + "jobConfig.errorOnVerify": true, + "jobConfig.iterationsPerNamespace": true, + "jobConfig.jobIterationDelay": true, + "jobConfig.jobIterations": false, + "jobConfig.jobPause": true, + "jobConfig.jobType": true, + "jobConfig.maxWaitTimeout": true, + "jobConfig.name": false, + "jobConfig.namespace": true, + "jobConfig.namespaceLabels.pod-security.kubernetes.io/audit": true, + "jobConfig.namespaceLabels.pod-security.kubernetes.io/enforce": true, + "jobConfig.namespaceLabels.pod-security.kubernetes.io/warn": true, + "jobConfig.namespaceLabels.security.openshift.io/scc.podSecurityLabelSync": true, + "jobConfig.namespaced": true, + "jobConfig.namespacedIterations": true, + "jobConfig.objects": true, + "jobConfig.podWait": true, + "jobConfig.preLoadImages": true, + "jobConfig.preLoadPeriod": true, + "jobConfig.verifyObjects": true, + "jobConfig.waitFor": true, + "jobConfig.waitForDeletion": true, + "jobConfig.waitWhenFinished": true, + "metadata.cloud-bulldozer": true, + "metadata.k8sVersion": true, + "metadata.ocpMajorVersion": true, + "metadata.ocpVersion": true, + "metadata.platform": true, + "metadata.sdnType": true, + "metadata.totalNodes": true, + "metricName": true, + "sort": true, + "timestamp": false, + "uuid": false + }, + "indexByName": { + "_id": 2, + "_index": 3, + "_type": 4, + "elapsedTime": 8, + "highlight": 19, + "jobConfig.burst": 7, + "jobConfig.churnDelay": 20, + "jobConfig.churnDuration": 21, + "jobConfig.churnPercent": 22, + "jobConfig.cleanup": 11, + "jobConfig.errorOnVerify": 12, + "jobConfig.iterationsPerNamespace": 23, + "jobConfig.jobIterations": 9, + "jobConfig.jobType": 10, + "jobConfig.maxWaitTimeout": 13, + "jobConfig.name": 5, + "jobConfig.namespace": 14, + "jobConfig.preLoadImages": 24, + "jobConfig.preLoadPeriod": 25, + "jobConfig.qps": 6, + "jobConfig.verifyObjects": 15, + "jobConfig.waitForDeletion": 16, + "jobConfig.waitWhenFinished": 17, + "metadata.k8sVersion": 26, + "metadata.ocpMajorVersion": 27, + "metadata.ocpVersion": 28, + "metadata.platform": 29, + "metadata.sdnType": 30, + "metadata.totalNodes": 31, + "metricName": 18, + "sort": 32, + "timestamp": 1, + "uuid": 0, + "version": 33 + }, + "renameByName": { + "_type": "", + "elapsedTime": "Elapsed time", + "elapsedTimeNs": "Elapsed Time", + "endTimestamp": "", + "highlight": "", + "jobConfig.burst": "Burst", + "jobConfig.churn": "Churn", + "jobConfig.churnDelay": "", + "jobConfig.churnDeletionStrategy": "Churn Deletion strategy", + "jobConfig.cleanup": "", + "jobConfig.errorOnVerify": "errorOnVerify", + "jobConfig.iterationsPerNamespace": "iterationsPerNs", + "jobConfig.jobIterationDelay": "jobIterationDelay", + "jobConfig.jobIterations": "Iterations", + "jobConfig.jobPause": "jobPause", + "jobConfig.jobType": "Job Type", + "jobConfig.maxWaitTimeout": "maxWaitTImeout", + "jobConfig.name": "Name", + "jobConfig.namespace": "namespacePrefix", + "jobConfig.namespaceLabels.pod-security.kubernetes.io/audit": "", + "jobConfig.namespaced": "", + "jobConfig.namespacedIterations": "Namespaced iterations", + "jobConfig.objects": "", + "jobConfig.podWait": "podWait", + "jobConfig.preLoadImages": "Preload Images", + "jobConfig.preLoadPeriod": "", + "jobConfig.qps": "QPS", + "jobConfig.verifyObjects": "", + "metadata.ocpMajorVersion": "Major version", + "metadata.platform": "Platform", + "metricName": "", + "timestamp": "Date", + "uuid": "UUID", + "version": "Kube-burner version" + } + } + } + ]) + + table.standardOptions.withOverrides([ + { + "matcher": { + "id": "byName", + "options": "Elapsed time" + }, + "properties": [ + { + "id": "unit", + "value": "s" + } + ] + }, + { + "matcher": { + "id": "byName", + "options": "Elapsed Time" + }, + "properties": [ + { + "id": "unit", + "value": "ns" + } + ] + } + ]) + + table.standardOptions.thresholds.withSteps([ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ]) + }, + + barGauge: { + local bargauge = g.panel.barGauge, + local options = bargauge.options, + + base(title, unit, targets, gridPos): + bargauge.new(title) + + bargauge.queryOptions.withTargets(targets) + + bargauge.datasource.withType('elasticsearch') + + bargauge.datasource.withUid('$Datasource') + + bargauge.standardOptions.withUnit(unit) + + bargauge.gridPos.withX(gridPos.x) + + bargauge.gridPos.withY(gridPos.y) + + bargauge.gridPos.withH(gridPos.h) + + bargauge.gridPos.withW(gridPos.w) + + options.withOrientation('horizontal') + + options.withDisplayMode('gradient') + + options.withValueMode('color') + + options.withShowUnfilled(true) + + options.withMinVizWidth(0) + + options.withMinVizHeight(10) + + options.text.withTitleSize(12), + + withnodeCPUUsage(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + bargauge.panelOptions.withRepeat('node_roles') + + bargauge.standardOptions.withMin(0) + + options.reduceOptions.withCalcs([ + 'lastNotNull', + ]), + + withnodeMemoryUsage(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + bargauge.panelOptions.withRepeat('node_roles') + + bargauge.standardOptions.withMin(5) + + options.reduceOptions.withCalcs([ + 'lastNotNull', + ]) + + bargauge.standardOptions.color.withFixedColor("dark-red") + + bargauge.standardOptions.color.withMode("palette-classic"), + + withP99PodReadyLatency(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + bargauge.standardOptions.withMin(0) + + options.reduceOptions.withCalcs([ + 'lastNotNull', + ]) + + bargauge.standardOptions.color.withMode("palette-classic"), + + etcdCPUusage(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + options.withMinVizHeight(0) + + options.withMinVizWidth(10) + + options.reduceOptions.withCalcs([ + 'lastNotNull', + ]) + + bargauge.standardOptions.color.withMode("palette-classic"), + + + }, + + barChart: { + local barchart = g.panel.barChart, + local options = barchart.options, + local custom = barchart.fieldConfig.defaults.custom, + + base(title, unit, targets, gridPos): + barchart.new(title) + + barchart.datasource.withType('elasticsearch') + + barchart.datasource.withUid('$Datasource') + + barchart.standardOptions.withUnit(unit) + + barchart.queryOptions.withTargets(targets) + + barchart.gridPos.withX(gridPos.x) + + barchart.gridPos.withY(gridPos.y) + + barchart.gridPos.withH(gridPos.h) + + barchart.gridPos.withW(gridPos.w), + + BarchartOptionSettings(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + options.legend.withDisplayMode("list") + + options.legend.withPlacement("bottom") + + options.legend.withShowLegend(true) + + options.withOrientation('horizontal') + + options.withBarWidth(0.97) + + options.withGroupWidth(0.7), + + ReadOnlyAPIrequestP99latency(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withLog(2) + + custom.scaleDistribution.withType('log'), + + + maxClusterCPUusageRatio(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withType('linear'), + + etcdScaleDistribution(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withLog(10) + + custom.scaleDistribution.withType('log'), + + etcdroundtrip(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withLog(10) + + custom.scaleDistribution.withType('log') + + barchart.standardOptions.color.withMode('continuous-RdYlGr'), + + ComponentRepeatPanelsBlue(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withLog(2) + + custom.scaleDistribution.withType('log') + + barchart.standardOptions.color.withMode('fixed') + + barchart.standardOptions.color.withFixedColor('blue'), + + ComponentRepeatPanelsRed(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withLog(2) + + custom.scaleDistribution.withType('log') + + barchart.standardOptions.color.withMode('fixed') + + barchart.standardOptions.color.withFixedColor('red'), + + ComponentRepeatPanelsYellow(title, unit, targets, gridPos): + self.BarchartOptionSettings(title, unit, targets, gridPos) + + custom.scaleDistribution.withLog(2) + + custom.scaleDistribution.withType('log') + + barchart.standardOptions.color.withMode('fixed') + + barchart.standardOptions.color.withFixedColor('yellow'), + + + }, + + timeSeries: { + local timeSeries = g.panel.timeSeries, + local custom = timeSeries.fieldConfig.defaults.custom, + local options = timeSeries.options, + + base(title, unit, targets, gridPos, maxPoints): + timeSeries.new(title) + + timeSeries.queryOptions.withTargets(targets) + + timeSeries.queryOptions.withMaxDataPoints(maxPoints) + + timeSeries.datasource.withType('elasticsearch') + + timeSeries.datasource.withUid('$Datasource') + + timeSeries.standardOptions.withUnit(unit) + + timeSeries.gridPos.withX(gridPos.x) + + timeSeries.gridPos.withY(gridPos.y) + + timeSeries.gridPos.withH(gridPos.h) + + timeSeries.gridPos.withW(gridPos.w) + + custom.withSpanNulls(true) + + custom.withFillOpacity(10) + + options.tooltip.withMode('multi') + + options.tooltip.withSort('desc') + + options.legend.withShowLegend(true) + + options.legend.withPlacement('bottom') + + options.legend.withDisplayMode('table'), + + withCommonAggregations(title, unit, targets, gridPos, maxPoints): + self.base(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'mean', + 'max', + 'min' + ]), + + withMeanMax(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'mean', + 'max', + ]), + + sortByMean(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + options.legend.withSortBy('Mean') + + options.legend.withSortDesc(true), + + sortByMax(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'max', + 'mean', + ]) + + options.legend.withSortBy('Max') + + options.legend.withSortDesc(true), + + sortByMeanCommon(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withSortBy('Mean') + + options.legend.withSortDesc(true), + + }, + + +} \ No newline at end of file diff --git a/assets/kube-burner-report-mode/queries.libsonnet b/assets/kube-burner-report-mode/queries.libsonnet new file mode 100644 index 0000000..ff84285 --- /dev/null +++ b/assets/kube-burner-report-mode/queries.libsonnet @@ -0,0 +1,814 @@ +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; +local variables = import './variables.libsonnet'; +local elasticsearch = g.query.elasticsearch; + +{ + + benchmarkOveriew: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.RawData.settings.withSize("500") + + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withType('raw_data'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: clusterMetadata') + + elasticsearch.withTimeField('timestamp') + }, + + garbageCollection: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.RawData.settings.withSize("500") + + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withType('raw_data'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: jobSummary') + + elasticsearch.withTimeField('timestamp') + }, + + nodeCPUusage: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("1") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: cpu-$node_roles') + + elasticsearch.withTimeField('timestamp') + }, + + maximumCPUusage: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("1") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-cpu-$node_roles') + + elasticsearch.withTimeField('timestamp') + }, + + masterMemoryUsage: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("1") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: memory-$node_roles') + + elasticsearch.withTimeField('timestamp') + }, + + maximumAggregatedMemory: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("1") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-memory-sum-$node_roles') + + elasticsearch.withTimeField('timestamp') + }, + + maxClusterCPUusageRatio: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-cpu-cluster-usage-ratio') + + elasticsearch.withTimeField('timestamp') + }, + + maxClusterMemoryUsageratio: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-memory-cluster-usage-ratio') + + elasticsearch.withTimeField('timestamp') + }, + + P99PodReadyLatency: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("6") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("7") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("P99") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: podLatencyQuantilesMeasurement AND quantileName.keyword: Ready') + + elasticsearch.withTimeField('timestamp') + }, + + P99ServiceReadyLatency: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("6") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("7") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("P99") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: svcLatencyQuantilesMeasurement AND quantileName.keyword: Ready') + + elasticsearch.withTimeField('timestamp') + }, + + ovnKubeMasterPodStats: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('10s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withType('sum'), + ]) + + elasticsearch.withQuery(query) + + elasticsearch.withTimeField('timestamp'), + queries(metric): [ + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.pod.keyword: /ovnkube-master.*/"), + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.pod.keyword: /ovnkube-control-plane.*/"), + ] + }, +# OVNkube control plane container stats + ovnKubeMasterContainerStats: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.container.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('10s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withType('sum'), + ]) + + elasticsearch.withQuery(query) + + elasticsearch.withTimeField('timestamp'), + queries(metric): [ + self.base("{{labels.container.keyword}}", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" labels.container.keyword: /ovnkube-master.*/"), + self.base("{{labels.container.keyword}}", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" labels.container: /ovnkube-control-plane.*/"), + ] + }, + + ReadOnlyAPIRequestP99LatencyResourceScoped: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: avg-ro-apicalls-latency AND labels.scope.keyword: resource') + + elasticsearch.withTimeField('timestamp') + }, + + MaxReadOnlyAPIrequestP99ResourceScoped:{ + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-ro-apicalls-latency AND labels.scope.keyword: resource') + + elasticsearch.withTimeField('timestamp') + }, + + ReadonlyAPIrequestP99LatencyNamespaceScoped: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: avg-ro-apicalls-latency AND labels.scope.keyword: namespace') + + elasticsearch.withTimeField('timestamp') + }, + + MaxReadOnlyAPIrequestP99LatencyNamespaceScoped: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-ro-apicalls-latency AND labels.scope.keyword: namespace') + + elasticsearch.withTimeField('timestamp'), + }, + + ReadOnlyAPIrequestP99LatencyClusterScoped: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: avg-ro-apicalls-latency AND labels.scope.keyword: cluster') + + elasticsearch.withTimeField('timestamp'), + }, + + MaxReadonlyAPIrequestP99LatencyClusterScoped: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-ro-apicalls-latency AND labels.scope.keyword: cluster') + + elasticsearch.withTimeField('timestamp'), + }, + + MutatingAPIrequestP99Latency: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: avg-mutating-apicalls-latency') + + elasticsearch.withTimeField('timestamp'), + }, + + MaxMutatingAPIrequestP99Latency: { + query(): + elasticsearch.withAlias("Memory") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-mutating-apicalls-latency') + + elasticsearch.withTimeField('timestamp'), + }, + + etcd99thWALfsync:{ + query(): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: 99thEtcdDiskWalFsync') + + elasticsearch.withTimeField('timestamp'), + }, + + Max99thWALfsync:{ + query(): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-99thEtcdDiskWalFsync') + + elasticsearch.withTimeField('timestamp'), + }, + + etcd99Roundtrip: { + query(): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: 99thEtcdRoundTripTime') + + elasticsearch.withTimeField('timestamp'), + }, + + Max99Roundtrip:{ + query(): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-99thEtcdRoundTripTime') + + elasticsearch.withTimeField('timestamp'), + }, + + etcd99BackendIandO: { + query(): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: 99thEtcdDiskBackendCommit') + + elasticsearch.withTimeField('timestamp'), + }, + + Max99thBackendIandO:{ + query(): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-99thEtcdDiskBackendCommit') + + elasticsearch.withTimeField('timestamp'), + }, + + etcdCPUusage:{ + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0) + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: cpu-etcd') + + elasticsearch.withTimeField('timestamp'), + }, + + MaxetcdCPUusage: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0) + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-cpu-etcd') + + elasticsearch.withTimeField('timestamp'), + }, + + etcdRSSusage: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0) + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: memory-etcd') + + elasticsearch.withTimeField('timestamp'), + }, + + etcdMaxRSSusage: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("3") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("0") + + elasticsearch.bucketAggs.DateHistogram.settings.withTimeZone("utc") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0) + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: memory-etcd') + + elasticsearch.withTimeField('timestamp'), + }, + + AvgRSSUsageComponet: { + query(): + elasticsearch.withAlias("RSS") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: memory-${component:raw}') + + elasticsearch.withTimeField('timestamp'), + }, + + MaxAggregatedRSSUsageComponent: { + query(): + elasticsearch.withAlias("RSS") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-memory-sum-${component:raw}') + + elasticsearch.withTimeField('timestamp'), + }, + + MaxRSSUsageComponent: { + query(): + elasticsearch.withAlias("RSS") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-memory-${component:raw}') + + elasticsearch.withTimeField('timestamp'), + }, + AvgCPUUsageComponent: { + query(): + elasticsearch.withAlias("RSS") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: cpu-${component:raw}') + + elasticsearch.withTimeField('timestamp'), + }, + + MaxCPUUsageComponent: { + query(): + elasticsearch.withAlias("RSS") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("$compare_by.keyword") + + elasticsearch.bucketAggs.Terms.withId("2") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: max-cpu-${component:raw}') + + elasticsearch.withTimeField('timestamp'), + } +} \ No newline at end of file diff --git a/assets/kube-burner-report-mode/variables.libsonnet b/assets/kube-burner-report-mode/variables.libsonnet new file mode 100644 index 0000000..d3f2163 --- /dev/null +++ b/assets/kube-burner-report-mode/variables.libsonnet @@ -0,0 +1,85 @@ +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; +local var = g.dashboard.variable; + +{ + Datasource: + var.datasource.new('Datasource','elasticsearch') + + var.datasource.withRegex('/.*kube-burner.*/') + + var.query.withRefresh(1) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.selectionOptions.withMulti(false), + + platform: + var.query.new('platform', '{"find": "terms", "field": "platform.keyword"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(2) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Platform'), + + sdn: + var.query.new('sdn', '{"find": "terms", "field": "sdnType.keyword", "query": "platform.keyword: $platform"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('SDN type'), + + clusterType: + var.query.new('clusterType', '{"find": "terms", "field": "clusterType.keyword", "query": "platform.keyword: $platform"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(true) + + var.query.generalOptions.withLabel('Cluster Type'), + + benchmark: + var.query.new('benchmark', '{"find": "terms", "field": "benchmark.keyword", "query": "platform.keyword: $platform AND sdnType.keyword: $sdn AND clusterType.keyword: $clusterType"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(false) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Benchmark'), + + workerNodesCount: + var.query.new('workerNodesCount', '{"find": "terms", "field": "workerNodesCount", "query": "platform.keyword: $platform AND sdnType.keyword: $sdn AND benchmark.keyword: $benchmark AND clusterType.keyword: $clusterType"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(false) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Workers'), + + ocpMajorVersion: + var.query.new('ocpMajorVersion', '{"find": "terms", "field": "ocpMajorVersion.keyword", "query": "platform.keyword: $platform AND sdnType.keyword: $sdn AND benchmark.keyword: $benchmark AND workerNodesCount: $workerNodesCount AND clusterType.keyword: $clusterType"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('OCP Major'), + + uuid: + var.query.new('uuid', '{"find": "terms", "field": "uuid.keyword", "query": "platform.keyword: $platform AND sdnType.keyword: $sdn AND benchmark.keyword: $benchmark AND workerNodesCount: $workerNodesCount AND ocpMajorVersion.keyword: $ocpMajorVersion AND clusterType.keyword: $clusterType"}') + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('UUID'), + + compare_by: + var.custom.new('compare_by', ['uuid', 'metadata.ocpVersion', 'metadata.ocpMajorVersion']) + + var.custom.generalOptions.withLabel('Compare by') + + var.custom.selectionOptions.withIncludeAll(false) + + var.custom.selectionOptions.withMulti(false), + + component: + var.custom.new('component', ['crio', 'kube-apiserver', 'kube-controller-manager','kubelet','multus','openshift-apiserver','openshift-controller-manager','ovn-control-plane','ovnkube-node','prometheus','router']) + + var.custom.generalOptions.withLabel('Component') + + var.custom.selectionOptions.withIncludeAll(true) + + var.custom.selectionOptions.withMulti(true), + + node_roles: + var.custom.new('node_roles', ['masters', 'workers', 'infra']) + + var.custom.generalOptions.withLabel('Node roles') + + var.custom.selectionOptions.withIncludeAll(false) + + var.custom.selectionOptions.withMulti(true), +} \ No newline at end of file diff --git a/templates/CPT/kube-burner-report-mode-v2.jsonnet b/templates/CPT/kube-burner-report-mode-v2.jsonnet new file mode 100644 index 0000000..2db9881 --- /dev/null +++ b/templates/CPT/kube-burner-report-mode-v2.jsonnet @@ -0,0 +1,92 @@ +local panels = import '../../assets/kube-burner-report-mode/panels.libsonnet'; +local queries = import '../../assets/kube-burner-report-mode/queries.libsonnet'; +local variables = import '../../assets/kube-burner-report-mode/variables.libsonnet'; +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; + +g.dashboard.new('Kube-burner Report Mode') ++ g.dashboard.withDescription(||| + Dashboard for kube-burner Mode +|||) ++ g.dashboard.withTags('kube-burner') ++ g.dashboard.time.withFrom('2024-01-28 00:00:00') ++ g.dashboard.time.withTo('2024-01-29 23:59:59') ++ g.dashboard.withTimezone('utc') ++ g.dashboard.timepicker.withRefreshIntervals(['5s', '10s', '30s', '1m', '5m', '15m', '30m', '1h', '2h', '1d']) ++ g.dashboard.timepicker.withTimeOptions(['5m', '15m', '1h', '6h', '12h', '24h', '2d', '7d', '30d']) ++ g.dashboard.withRefresh('') ++ g.dashboard.withEditable(true) ++ g.dashboard.graphTooltip.withSharedCrosshair() ++ g.dashboard.withVariables([ + variables.Datasource, + variables.platform, + variables.sdn, + variables.clusterType, + variables.benchmark, + variables.workerNodesCount, + variables.ocpMajorVersion, + variables.uuid, + variables.compare_by, + variables.component, + variables.node_roles, +]) ++ g.dashboard.withPanels([ + panels.table.withBenchmarkOverview('', '', queries.benchmarkOveriew.query(), { x: 6, y: 0, w: 24, h: 6 }), + panels.table.withGarbageCollection('', '', queries.garbageCollection.query(), { x: 0, y: 6, w: 24, h: 5 }), + g.panel.row.new('Node Usage') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.barGauge.withnodeCPUUsage('$workerNodesCount nodes - CPU usage $node_roles', 'cores', queries.nodeCPUusage.query(), { x: 0, y: 12, w: 24, h: 4 }), + panels.barGauge.withnodeCPUUsage('Maximum CPU usage $node_roles', 'cores', queries.maximumCPUusage.query(), { x: 4, y: 16, w: 8, h: 4 }), + panels.barGauge.withnodeMemoryUsage('$workerNodesCount nodes - Memory usage $node_roles', 'bytes', queries.masterMemoryUsage.query(), { x: 0, y: 20, w: 8, h: 4 }), + panels.barGauge.withnodeMemoryUsage('$workerNodesCount nodes - Maximum aggregated memory usage $node_roles', 'bytes', queries.maximumAggregatedMemory.query(), { x: 0, y: 24, w: 8, h: 4 }), + panels.barChart.maxClusterCPUusageRatio('Max Cluster CPU usage ratio', '', queries.maxClusterCPUusageRatio.query(), { x: 0, y: 28, w: 7, h: 6 }), + panels.barChart.maxClusterCPUusageRatio('Max Cluster memory usage ratio', '', queries.maxClusterMemoryUsageratio.query(), { x: 7, y: 28, w: 7, h: 6 }), + ]), + g.panel.row.new('Pod & Service ready latency') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.barGauge.withP99PodReadyLatency('P99 Pod ready latency', 'ms', queries.P99PodReadyLatency.query(), { x: 0, y: 13, w: 10, h: 6 }), + panels.barGauge.withP99PodReadyLatency('P99 Service ready latency', 'ns', queries.P99ServiceReadyLatency.query(), { x: 10, y: 35, w: 10, h: 6 }), + ]), + g.panel.row.new('API latency') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.barChart.ReadOnlyAPIrequestP99latency('Read Only API request P99 latency - resource scoped', 's', queries.ReadOnlyAPIRequestP99LatencyResourceScoped.query(), { x: 0, y: 14, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Maximum Read Only API request P99 latency - resource scoped', 's', queries.MaxReadOnlyAPIrequestP99ResourceScoped.query(), { x: 12, y: 14, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Read Only API request P99 latency - namespace scoped', 's', queries.ReadonlyAPIrequestP99LatencyNamespaceScoped.query(), { x: 0, y: 20, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Maximum Read Only API request P99 latency - namespace scoped', 's', queries.MaxReadOnlyAPIrequestP99LatencyNamespaceScoped.query(), { x: 12, y: 20, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Read Only API request P99 latency - cluster scoped', 's', queries.ReadOnlyAPIrequestP99LatencyClusterScoped.query(), { x: 0, y: 26, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Maximum Read Only API request P99 latency - cluster scoped', 's', queries.MaxReadonlyAPIrequestP99LatencyClusterScoped.query(), { x: 12, y: 26, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Mutating API request P99 latency', 's', queries.MutatingAPIrequestP99Latency.query(), { x: 0, y: 32, w: 12, h: 6 }), + panels.barChart.ReadOnlyAPIrequestP99latency('Maximum Mutating API request P99 latency', 's', queries.MaxMutatingAPIrequestP99Latency.query(), { x: 12, y: 32, w: 12, h: 6 }), + ]), + g.panel.row.new('ETCD') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.barChart.etcdScaleDistribution('99th WAL fsync', 's', queries.etcd99thWALfsync.query(), { x: 0, y: 15, w: 7, h: 5 }), + panels.barChart.etcdScaleDistribution('Maximum 99th WAL fsync', 's', queries.Max99thWALfsync.query(), { x: 7, y: 15, w: 11, h: 5 }), + panels.barChart.etcdroundtrip('99th Roundtrip', 's', queries.etcd99Roundtrip.query(), { x: 0, y: 20, w: 7, h: 5 }), + panels.barChart.etcdroundtrip('Maximum 99th Roundtrip', 's', queries.Max99Roundtrip.query(), { x: 7, y: 20, w: 11, h: 5 }), + panels.barChart.etcdScaleDistribution('99th Backend I/O', 's', queries.etcd99BackendIandO.query(), { x: 0, y: 25, w: 7, h: 5 }), + panels.barChart.etcdScaleDistribution('Maximum 99th Backend I/O', 's', queries.Max99thBackendIandO.query(), { x: 7, y: 25, w: 11, h: 5 }), + panels.barGauge.etcdCPUusage('Etcd CPU usage', 'cores', queries.etcdCPUusage.query(), { x: 0, y: 30, w: 7, h: 6 }), + panels.barGauge.etcdCPUusage('Maximum Etcd CPU usage', 'cores', queries.MaxetcdCPUusage.query(), { x: 7, y: 30, w: 7, h: 6 }), + panels.barGauge.etcdCPUusage('Etcd RSS usage', 'bytes', queries.etcdRSSusage.query(), { x: 0, y: 36, w: 7, h: 6 }), + panels.barGauge.etcdCPUusage('Etcd max RSS usage', 'bytes', queries.etcdMaxRSSusage.query(), { x: 7, y: 36, w: 7, h: 6 }), + ]), + g.panel.row.new('$component') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withRepeat('component') + + g.panel.row.withPanels([ + panels.barChart.ComponentRepeatPanelsBlue('Average RSS Usage $component', 'bytes', queries.AvgRSSUsageComponet.query(), { x: 0, y: 43, w: 9, h: 10 }), + panels.barChart.ComponentRepeatPanelsRed('Max Aggregated RSS Usage $component', 'bytes', queries.MaxAggregatedRSSUsageComponent.query(), { x: 9, y: 43, w: 8, h: 10 }), + panels.barChart.ComponentRepeatPanelsRed('Max RSS Usage $component', 'bytes', queries.MaxRSSUsageComponent.query(), { x: 17, y: 43, w: 7, h: 10 }), + panels.barChart.ComponentRepeatPanelsYellow('Average CPU Usage $component', 'cores', queries.AvgCPUUsageComponent.query(), { x: 0, y: 53, w: 11, h: 5 }), + panels.barChart.ComponentRepeatPanelsYellow('Maximum CPU Usage $component', 'cores', queries.MaxCPUUsageComponent.query(), { x: 11, y: 53, w: 13, h: 5 }), + ]), +])