diff --git a/Makefile b/Makefile index 2b6a8ff..71dcc65 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,5 @@ -JSONNET = https://github.com/google/jsonnet/releases/download/v0.17.0/jsonnet-bin-v0.17.0-linux.tar.gz +JSONNET := https://github.com/google/go-jsonnet/releases/download/v0.20.0/go-jsonnet_0.20.0_Linux_x86_64.tar.gz +JB = https://github.com/jsonnet-bundler/jsonnet-bundler/releases/latest/download/jb-linux-amd64 BINDIR = bin TEMPLATESDIR = templates OUTPUTDIR = rendered @@ -6,15 +7,22 @@ ALLDIRS = $(BINDIR) $(OUTPUTDIR) SYNCER_IMG_TAG ?= quay.io/cloud-bulldozer/dittybopper-syncer:latest PLATFORM = linux/amd64,linux/arm64,linux/ppc64le,linux/s390x -# Get all templates at $(TEMPLATESDIR) -TEMPLATES := $(wildcard $(TEMPLATESDIR)/**/*.jsonnet) +ifeq ($(filter v2,$(MAKECMDGOALS)),v2) + # Set variables and instructions for v2 + TEMPLATES := $(wildcard $(TEMPLATESDIR)/**/*-v2.jsonnet) + LIBRARY_PATH := $(TEMPLATESDIR)/vendor +else + # Get all templates at $(TEMPLATESDIR) + TEMPLATES := $(filter-out %-v2.jsonnet, $(wildcard $(TEMPLATESDIR)/**/*.jsonnet)) + LIBRARY_PATH := $(TEMPLATESDIR)/grafonnet-lib +endif # Replace $(TEMPLATESDIR)/*.jsonnet by $(OUTPUTDIR)/*.json outputs := $(patsubst $(TEMPLATESDIR)/%.jsonnet, $(OUTPUTDIR)/%.json, $(TEMPLATES)) all: deps format build -deps: $(ALLDIRS) $(TEMPLATESDIR)/grafonnet-lib $(BINDIR)/jsonnet +deps: $(ALLDIRS) $(BINDIR)/jsonnet $(LIBRARY_PATH) $(ALLDIRS): mkdir -p $(ALLDIRS) @@ -22,27 +30,37 @@ $(ALLDIRS): format: deps $(BINDIR)/jsonnetfmt -i $(TEMPLATES) -build: deps $(TEMPLATESDIR)/grafonnet-lib $(outputs) +build: deps $(LIBRARY_PATH) $(outputs) clean: @echo "Cleaning up" - rm -rf $(ALLDIRS) $(TEMPLATESDIR)/grafonnet-lib - -$(TEMPLATESDIR)/grafonnet-lib: - git clone --depth 1 https://github.com/grafana/grafonnet-lib.git $(TEMPLATESDIR)/grafonnet-lib + rm -rf $(ALLDIRS) $(TEMPLATESDIR)/vendor $(TEMPLATESDIR)/grafonnet-lib $(BINDIR)/jsonnet: @echo "Downloading jsonnet binary" curl -s -L $(JSONNET) | tar xz -C $(BINDIR) + @echo "Downloading jb binary" + curl -s -L $(JB) -o $(BINDIR)/jb + chmod +x $(BINDIR)/jb + +$(TEMPLATESDIR)/grafonnet-lib: + git clone --depth 1 https://github.com/grafana/grafonnet-lib.git $(TEMPLATESDIR)/grafonnet-lib + +$(TEMPLATESDIR)/vendor: + @echo "Downloading vendor files" + cd $(TEMPLATESDIR) && ../$(BINDIR)/jb install && cd ../ # Build each template and output to $(OUTPUTDIR) $(OUTPUTDIR)/%.json: $(TEMPLATESDIR)/%.jsonnet @echo "Building template $<" mkdir -p $(dir $@) - $(BINDIR)/jsonnet $< > $@ + $(BINDIR)/jsonnet -J ./$(LIBRARY_PATH) $< > $@ + +v2: all + @echo "Rendered the v2 dashboards with latest grafonnet library" build-syncer-image: build podman build --platform=${PLATFORM} -f Dockerfile --manifest=${SYNCER_IMG_TAG} . push-syncer-image: - podman manifest push ${SYNCER_IMG_TAG} ${SYNCER_IMG_TAG} \ No newline at end of file + podman manifest push ${SYNCER_IMG_TAG} ${SYNCER_IMG_TAG} diff --git a/README.md b/README.md index e30f773..674f57d 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ mkdir -p bin rendered tmp git clone --depth 1 https://github.com/grafana/grafonnet-lib.git templates/grafonnet-lib Cloning into 'templates/grafonnet-lib'... Downloading jsonnet binary -curl -s -L https://github.com/google/jsonnet/releases/download/v0.15.0/jsonnet-bin-v0.15.0-linux.tar.gz | tar xzf - -C bin +curl -s -L https://github.com/google/go-jsonnet/releases/download/v0.20.0/go-jsonnet_0.20.0_Linux_x86_64.tar.gz | tar xz -C bin Formating template templates/ocp-performance.jsonnet bin/jsonnetfmt templates/ocp-performance.jsonnet > tmp/ocp-performance.jsonnet mv tmp/ocp-performance.jsonnet templates/ocp-performance.jsonnet @@ -34,6 +34,28 @@ bin/jsonnet templates/ocp-performance.jsonnet > rendered/ocp-performance.json $ ls rendered ocp-ingress-controller.json ocp-performance.json ``` +Similarly for V2, the dashboards that are built using latest grafonnet library, use +``` +$ make v2 +mkdir -p bin rendered +Downloading jsonnet binary +curl -s -L https://github.com/google/go-jsonnet/releases/download/v0.20.0/go-jsonnet_0.20.0_Linux_x86_64.tar.gz | tar xz -C bin +Downloading jb binary +curl -s -L https://github.com/jsonnet-bundler/jsonnet-bundler/releases/latest/download/jb-linux-amd64 -o bin/jb +chmod +x bin/jb +Downloading vendor files +cd templates && ../bin/jb install && cd ../ +GET https://github.com/grafana/grafonnet/archive/f40876da40d787e9c288de0b547ac85597c781d9.tar.gz 200 +GET https://github.com/grafana/grafonnet/archive/f40876da40d787e9c288de0b547ac85597c781d9.tar.gz 200 +GET https://github.com/jsonnet-libs/docsonnet/archive/cc9df63eaca56f39e8e4e1ce192141333257b08d.tar.gz 200 +GET https://github.com/jsonnet-libs/xtd/archive/0256a910ac71f0f842696d7bca0bf01ea77eb654.tar.gz 200 +bin/jsonnetfmt -i templates/General/ocp-performance-v2.jsonnet +Building template templates/General/ocp-performance-v2.jsonnet +mkdir -p rendered/General/ +bin/jsonnet -J ./templates/vendor templates/General/ocp-performance-v2.jsonnet > rendered/General/ocp-performance-v2.json +Rendered the v2 dashboards with latest grafonnet library +``` +All other operations remain same as before. In order to clean up the environment execute `make clean`. @@ -73,4 +95,4 @@ In addition, make sure to lint your modifications to jsonnet files if you don't The dashboards from this repository have been tested with the following versions: -- Grafana 7.X +- Grafana 7.X \ No newline at end of file diff --git a/assets/kube-burner-report-ocp-wrapper/panels.libsonnet b/assets/kube-burner-report-ocp-wrapper/panels.libsonnet new file mode 100644 index 0000000..b240e9c --- /dev/null +++ b/assets/kube-burner-report-ocp-wrapper/panels.libsonnet @@ -0,0 +1,836 @@ +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; + +{ + 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' + ]), + + withCommonAggregationsRightPlacement(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withPlacement('right'), + + meanWithRightLegend(title, unit, targets, gridPos, maxPoints): + self.base(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'mean' + ]) + + options.legend.withPlacement('right'), + + withMeanMax(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'mean', + 'max', + ]), + + withMinMax(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'max', + 'min', + ]), + + sortByMeanCommon(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withSortBy('Mean') + + options.legend.withSortDesc(true), + + sortByMaxCommon(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withSortBy('Max') + + options.legend.withSortDesc(true), + + 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), + + sortByMin(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withSortBy('Min') + + options.legend.withSortDesc(false), + + meanWithRightLegendCommons(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'mean', + 'max', + 'lastNotNull', + ]) + + options.legend.withPlacement('right') + + options.legend.withSortBy('Mean') + + options.legend.withSortDesc(true), + + maxMeanWithRightLegend(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'mean', + 'max', + ]) + + options.legend.withPlacement('right'), + + minMaxWithRightLegend(title, unit, targets, gridPos, maxPoints): + self.withMinMax(title, unit, targets, gridPos, maxPoints) + + options.legend.withPlacement('right'), + + sortMaxWithRightLegend(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'lastNotNull', + 'max', + ]) + + options.legend.withPlacement('right') + + options.legend.withSortBy('Max') + + options.legend.withSortDesc(true), + + maxWithRightLegend(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'lastNotNull', + 'max', + ]) + + options.legend.withPlacement('right'), + + allWithRightLegend(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + "max", + "min", + "firstNotNull", + "lastNotNull" + ]) + + options.legend.withPlacement('right'), + + maxWithBottomLegend(title, unit, targets, gridPos, maxPoints): + self.withCommonAggregations(title, unit, targets, gridPos, maxPoints) + + options.legend.withCalcs([ + 'max', + 'lastNotNull', + ]) + + options.legend.withSortBy('Max') + + options.legend.withSortDesc(true), + + workerCPUCustomOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + options.legend.withPlacement('right') + + timeSeries.standardOptions.withOverrides([ + { + "__systemRef": "hideSeriesFrom", + "matcher": { + "id": "byNames", + "options": { + "mode": "exclude", + "names": [ + "user", + "system", + "softirq", + "iowait", + "irq" + ], + "prefix": "All except:", + "readOnly": true + } + }, + "properties": [ + { + "id": "custom.hideFrom", + "value": { + "legend": false, + "tooltip": false, + "viz": true + } + } + ] + } + ]), + + kupeApiCustomOverrides(title, unit, targets, gridPos, maxPoints): + self.sortByMax(title, unit, targets, gridPos, maxPoints) + + options.tooltip.withMode('multi') + + options.legend.withSortDesc(false) + + timeSeries.standardOptions.withOverrides([ + { + "matcher": { + "id": "byRegexp", + "options": "/Rss.*/" + }, + "properties": [ + { + "id": "custom.showPoints", + "value": "always" + }, + { + "id": "unit", + "value": "bytes" + } + ] + } + ]), + kupeApiAverageCustomOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.withOverrides([ + { + "matcher": { + "id": "byRegexp", + "options": "/Rss.*/" + }, + "properties": [ + { + "id": "custom.showPoints", + "value": "auto" + }, + { + "id": "unit", + "value": "bytes" + } + ] + }, + { + "__systemRef": "hideSeriesFrom", + "matcher": { + "id": "byNames", + "options": { + "mode": "exclude", + "names": [ + "Avg CPU kube-apiserver" + ], + "prefix": "All except:", + "readOnly": true + } + }, + "properties": [ + { + "id": "custom.hideFrom", + "value": { + "legend": false, + "tooltip": false, + "viz": true + } + } + ] + } + ]), + activeKubeControllerManagerOverrides(title, unit, targets, gridPos, maxPoints): + self.sortByMax(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.withOverrides([ + { + "matcher": { + "id": "byRegexp", + "options": "/Rss.*/" + }, + "properties": [ + { + "id": "custom.showPoints", + "value": "always" + }, + { + "id": "unit", + "value": "bytes" + } + ] + } + ]), + kubeSchedulerUsageOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.withOverrides([ + { + "matcher": { + "id": "byRegexp", + "options": "/Rss.*/" + }, + "properties": [ + { + "id": "custom.showPoints", + "value": "always" + }, + { + "id": "unit", + "value": "bytes" + } + ] + } + ]), + etcd99thNetworkPeerRTOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.withOverrides([ + { + "matcher": { + "id": "byRegexp", + "options": "/.*Logical.*/" + }, + "properties": [ + { + "id": "unit", + "value": "decbytes" + }, + { + "id": "custom.axisPlacement", + "value": "hidden" + } + ] + } + ]), + etcdResouceUtilizationOverrides(title, unit, targets, gridPos, maxPoints): + self.sortByMaxCommon(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.withOverrides([ + { + "matcher": { + "id": "byRegexp", + "options": "/Rss.*/" + }, + "properties": [ + { + "id": "custom.showPoints", + "value": "always" + }, + { + "id": "unit", + "value": "bytes" + } + ] + } + ]), + etcd99thDiskWalLatencyOverrides(title, unit, targets, gridPos, maxPoints): + self.sortByMean(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.thresholds.withMode("absolute") + + custom.withThresholdsStyle({ + "mode": "line+area" + }) + + timeSeries.standardOptions.thresholds.withSteps([ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 0.01 + } + ]) + + timeSeries.standardOptions.color.withMode("palette-classic"), + etcd99thCommitLatencyOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + timeSeries.standardOptions.thresholds.withMode("absolute") + + custom.withThresholdsStyle({ + "mode": "line+area" + }) + + timeSeries.standardOptions.thresholds.withSteps([ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 0.02 + } + ]) + + timeSeries.standardOptions.color.withMode("palette-classic"), + readOnlyAPIRequestp99ResourceOverrides(title, unit, targets, gridPos, maxPoints): + self.sortByMax(title, unit, targets, gridPos, maxPoints) + + custom.withThresholdsStyle({ + "mode": "line+area" + }) + + timeSeries.standardOptions.thresholds.withSteps([ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 1 + } + ]), + readOnlyAPIRequestp99NamespaceOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + custom.withThresholdsStyle({ + "mode": "line+area" + }) + + timeSeries.standardOptions.thresholds.withSteps([ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 5 + } + ]), + readOnlyAPIRequestp99ClusterOverrides(title, unit, targets, gridPos, maxPoints): + self.withMeanMax(title, unit, targets, gridPos, maxPoints) + + custom.withThresholdsStyle({ + "mode": "line+area" + }) + + timeSeries.standardOptions.thresholds.withSteps([ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 30 + } + ]), + readOnlyAPIRequestp99MutatingOverrides(title, unit, targets, gridPos, maxPoints): + self.sortByMax(title, unit, targets, gridPos, maxPoints) + + custom.withThresholdsStyle({ + "mode": "line+area" + }) + + timeSeries.standardOptions.thresholds.withSteps([ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 1 + } + ]), + }, + stat: { + local stat = g.panel.stat, + local options = stat.options, + + base(title, unit, targets, gridPos): + stat.new(title) + + stat.datasource.withType('elasticsearch') + + stat.datasource.withUid('$Datasource') + + stat.standardOptions.withUnit(unit) + + stat.queryOptions.withTargets(targets) + + stat.gridPos.withX(gridPos.x) + + stat.gridPos.withY(gridPos.y) + + stat.gridPos.withH(gridPos.h) + + stat.gridPos.withW(gridPos.w) + + options.withJustifyMode("center"), + + withMeanCalcs(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + options.reduceOptions.withCalcs([ + 'mean', + ]), + + withLastNotNullCalcs(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + options.reduceOptions.withCalcs([ + 'lastNotNull', + ]), + + withFieldSummary(title, unit, field, targets, gridPos): + self.withLastNotNullCalcs(title, unit, targets, gridPos) + + options.reduceOptions.withFields(field), + + withMeanThresholds(title, unit, targets, gridPos): + self.withMeanCalcs(title, unit, targets, gridPos) + + stat.standardOptions.thresholds.withMode("absolute") + + stat.standardOptions.thresholds.withSteps([{"value": null,"color": "green"}, {"value": 5000,"color": "red"}]) + + stat.standardOptions.color.withMode("palette-classic"), + }, + 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), + + withAlerts(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, + "metricName": true, + "sort": true, + "uuid": true + }, + "indexByName": {}, + "renameByName": { + "_type": "Desciption", + "severity": "Severity", + "timestamp": "Timestamp" + } + } + } + ]), + + withLatencyTableOverrides(title, unit, targets, gridPos): + self.withPagination(title, unit, targets, gridPos) + + table.options.withSortBy([ + { + "desc": true, + "displayName": "Initialized" + } + ]) + + table.queryOptions.withTransformations([ + { + "id": "organize", + "options": { + "excludeByName": {}, + "indexByName": {}, + "renameByName": { + "Average containersReadyLatency": "ContainersReady", + "Average initializedLatency": "Initialized", + "Average podReadyLatency": "Ready", + "Average schedulingLatency": "Scheduling", + "namespace.keyword": "Namespace", + "podName.keyword": "Pod" + } + } + } + ]) + + table.standardOptions.withOverrides([ + { + "matcher": { + "id": "byName", + "options": "nodeName.keyword" + }, + "properties": [ + { + "id": "custom.width", + "value": 412 + } + ] + } + ]), + + withJobSummary(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + table.options.withSortBy([]) + + 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.jobIterationDelay": true, + "jobConfig.jobIterations": false, + "jobConfig.jobPause": true, + "jobConfig.jobType": true, + "jobConfig.maxWaitTimeout": true, + "jobConfig.name": true, + "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.ocpVersion": true, + "metadata.platform": true, + "metadata.sdnType": true, + "metadata.totalNodes": true, + "metricName": true, + "sort": true, + "timestamp": true, + "uuid": false + }, + "indexByName": { + "_id": 1, + "_index": 2, + "_type": 3, + "elapsedTime": 8, + "jobConfig.burst": 7, + "jobConfig.cleanup": 12, + "jobConfig.errorOnVerify": 13, + "jobConfig.jobIterationDelay": 14, + "jobConfig.jobIterations": 9, + "jobConfig.jobPause": 15, + "jobConfig.jobType": 10, + "jobConfig.maxWaitTimeout": 16, + "jobConfig.name": 5, + "jobConfig.namespace": 17, + "jobConfig.namespacedIterations": 18, + "jobConfig.objects": 19, + "jobConfig.podWait": 11, + "jobConfig.qps": 6, + "jobConfig.verifyObjects": 20, + "jobConfig.waitFor": 21, + "jobConfig.waitForDeletion": 22, + "jobConfig.waitWhenFinished": 23, + "metricName": 24, + "timestamp": 0, + "uuid": 4 + }, + "renameByName": { + "_type": "", + "elapsedTime": "Elapsed time", + "elapsedTimeNs": "Elapsed Time", + "highlight": "", + "jobConfig.burst": "Burst", + "jobConfig.churn": "Churn", + "jobConfig.churnDelay": "", + "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.platform": "Platform", + "metricName": "", + "timestamp": "", + "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" + } + ] + } + ]), + + withClusterMetadata(title, unit, targets, gridPos): + self.base(title, unit, targets, gridPos) + + table.options.withSortBy([]) + + table.standardOptions.withMappings([ + { + "options": { + "passed": { + "color": "green", + "index": 0 + } + }, + "type": "value" + } + ]) + + 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, + "metricName": true, + "ocp_version": true, + "platform": false, + "sdn_type": false, + "sort": true, + "timestamp": true, + "total_nodes": false, + "uuid": true, + "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" + } + } + ] + } + ]), + } +} \ No newline at end of file diff --git a/assets/kube-burner-report-ocp-wrapper/queries.libsonnet b/assets/kube-burner-report-ocp-wrapper/queries.libsonnet new file mode 100644 index 0000000..0d5e0aa --- /dev/null +++ b/assets/kube-burner-report-ocp-wrapper/queries.libsonnet @@ -0,0 +1,1584 @@ +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; +local variables = import './variables.libsonnet'; +local elasticsearch = g.query.elasticsearch; + +{ + averagePodLatency: { + query(): + elasticsearch.withAlias("{{field}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField('timestamp') + + elasticsearch.bucketAggs.DateHistogram.withId("5") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount(1) + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("podReadyLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("4") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("schedulingLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("3") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("initializedLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("2") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("containersReadyLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: podLatencyMeasurement') + + elasticsearch.withTimeField('timestamp') + }, + podLatenciesSummary: { + query(): + elasticsearch.withAlias("$latencyPercentile {{term quantileName.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("quantileName.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + 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.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Max.withField("$latencyPercentile") + + elasticsearch.metrics.MetricAggregationWithSettings.Max.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Max.withType('max'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: podLatencyQuantilesMeasurement') + + elasticsearch.withTimeField('timestamp') + }, + podConditionsLatency: { + query(): + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("namespace.keyword") + + elasticsearch.bucketAggs.Terms.withId("7") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("100"), + elasticsearch.bucketAggs.Terms.withField("nodeName.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("100"), + elasticsearch.bucketAggs.Terms.withField("podName.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("100"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("schedulingLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("4") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("initializedLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("3") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("containersReadyLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("2") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("podReadyLatency") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery('uuid.keyword: $uuid AND metricName.keyword: podLatencyMeasurement') + + elasticsearch.withQueryType('randomWalk') + + elasticsearch.withTimeField('timestamp') + }, + top10ContainerRuntimeNetworkSetupLatency: { + query(): + elasticsearch.withAlias("{{labels.node.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.node.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: containerNetworkSetupLatency') + + elasticsearch.withTimeField('timestamp') + }, + schedulingThroughput: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: schedulingThroughput') + + elasticsearch.withTimeField('timestamp') + }, + mastersCPUUtilization: { + queries(): [ + elasticsearch.withAlias("{{labels.instance.keyword}}") + + elasticsearch.withHide(false) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.instance.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.settings.withScript("_value * 100") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withType('sum'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: \"nodeCPU-Masters\" AND NOT labels.mode.keyword: idle AND NOT labels.mode.keyword: steal") + + elasticsearch.withTimeField('timestamp'), + elasticsearch.withAlias("Aggregated") + + elasticsearch.withHide(false) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.settings.withScript("_value * 100") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withType('sum'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: nodeCPU-Masters AND NOT labels.mode.keyword: idle AND NOT labels.mode.keyword: steal") + + elasticsearch.withTimeField('timestamp') + ] + }, + mastersMemoryUtilization: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withHide(false) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.instance.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Utilization {{labels.instance.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: nodeMemoryUtilization-Masters"), + self.base("Total {{labels.instance.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: nodeMemoryTotal-Masters"), + elasticsearch.withAlias("Aggregated utilization") + + elasticsearch.withHide(false) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1"), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Sum.withType('sum'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: nodeMemoryUtilization-Masters") + + elasticsearch.withTimeField('timestamp') + ] + }, + nodeStatusSummary: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.condition.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: \"nodeStatus\"") + + elasticsearch.withTimeField('timestamp') + }, + podStatusSummary: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.phase.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: \"podStatusCount\"") + + elasticsearch.withTimeField('timestamp') + }, + kubeApiServerUsage: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.Terms.withField("labels.container.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.Terms.withField("labels.namespace.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + 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('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerCPU\" AND labels.container.keyword: kube-apiserver"), + self.base("Rss {{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerMemory\" AND labels.container.keyword: kube-apiserver"), + self.base("Rss {{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerMemory-Masters\" AND labels.container.keyword: kube-apiserver"), + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerCPU-Masters\" AND labels.container.keyword: kube-apiserver"), + ] + }, + averageKubeApiServerUsage: { + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto'), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Avg CPU kube-apiserver", "uuid.keyword: $uuid AND metricName: \"containerCPU\" AND labels.container.keyword: kube-apiserver"), + self.base("Avg Rss kube-apiserver", "uuid.keyword: $uuid AND metricName: \"containerMemory\" AND labels.container.keyword: kube-apiserver"), + ] + }, + activeKubeControllerManagerUsage: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("1"), + elasticsearch.bucketAggs.Terms.withField("labels.container.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.Terms.withField("labels.namespace.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + 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('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerCPU\" AND labels.container.keyword: kube-controller-manager"), + self.base("Rss {{labels.namespace.keyword}}-{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerMemory\" AND labels.container.keyword: kube-controller-manager"), + self.base("{{labels.namespace.keyword}}-{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerCPU-Masters\" AND labels.container.keyword: kube-controller-manager"), + self.base("Rss {{labels.namespace.keyword}}-{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: \"containerMemory-Masters\" AND labels.container.keyword: kube-controller-manager"), + ] + }, + kubeSchedulerUsage: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("5") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.Terms.withField("labels.container.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + elasticsearch.bucketAggs.Terms.withField("labels.namespace.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + 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('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName: \"containerCPU\" AND labels.container.keyword: kube-scheduler"), + self.base("Rss {{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName: \"containerMemory\" AND labels.container.keyword: kube-scheduler"), + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName: \"containerCPU-Masters\" AND labels.container.keyword: kube-scheduler"), + self.base("Rss {{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName: \"containerMemory-Masters\" AND labels.container.keyword: kube-scheduler"), + ] + }, + nodeCount: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.role.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.Count.withId("1") + + elasticsearch.metrics.Count.withType('count'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName: \"nodeRoles\"") + + elasticsearch.withTimeField('timestamp') + }, + aggregatesCount: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Namespaces", "uuid.keyword: $uuid AND metricName: \"namespaceCount\" AND labels.phase: \"Active\""), + self.base("Services", "uuid.keyword: $uuid AND metricName: \"serviceCount\""), + self.base("Deployments", "uuid.keyword: $uuid AND metricName: \"deploymentCount\""), + self.base("Secrets", "uuid.keyword: $uuid AND metricName.keyword: \"secretCount\""), + self.base("ConfigMaps", "uuid.keyword: $uuid AND metricName.keyword: \"configmapCount\""), + ] + }, + openshiftVersion: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.RawData.settings.withSize("500") + + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withType('raw_data'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: \"etcdVersion\"") + + elasticsearch.withTimeField('timestamp') + }, + jobSummary: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withHide(false) + + elasticsearch.withBucketAggs([]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withId("1") + + 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') + }, + clusterMetadata: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withHide(false) + + elasticsearch.withBucketAggs([]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withId("1") + + 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') + }, + alerts: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.RawData.settings.withSize("500") + + elasticsearch.metrics.MetricAggregationWithSettings.RawData.withType('raw_data'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: alert") + + 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('30s') + + 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.*/"), + ] + }, + ovnKubeMasterStats: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + 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("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('30s') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(metric): [ + self.base("{{labels.pod.keyword}}-{{labels.container.keyword}}", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.pod.keyword: /ovnkube-master.*/"), + self.base("{{labels.pod.keyword}}-{{labels.container.keyword}}", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.pod.keyword: /ovnkube-control-plane.*/"), + ] + }, + ovnKubeNodePodStats: { + 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('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("5"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + 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.namespace.keyword: \"openshift-ovn-kubernetes\" AND labels.pod.keyword: /ovnkube-node.*/"), + elasticsearch.withAlias('Aggregated') + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + 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("uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.namespace.keyword: \"openshift-ovn-kubernetes\" AND labels.pod.keyword: /ovnkube-node.*/") + + elasticsearch.withTimeField('timestamp'), + ] + }, + ovnControllerStats: { + query(metric): + elasticsearch.withAlias("{{labels.pod.keyword}}") + + 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('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("5"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + 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: \""+ metric +"\" AND labels.namespace.keyword: \"openshift-ovn-kubernetes\" AND labels.pod.keyword: /ovnkube-node.*/ AND labels.container.keyword: \"ovn-controller\"") + + elasticsearch.withTimeField('timestamp') + }, + aggregatedOVNKubeMasterStats: { + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + 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("", "uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.pod.keyword: /ovnkube-master.*/"), + self.base("","uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.pod.keyword: /ovnkube-control-plane.*/"), + ], + }, + aggregatedOVNKubeNodeStats: { + query(metric): + elasticsearch.withAlias("") + + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + 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("uuid.keyword: $uuid AND metricName: \""+ metric +"\" AND labels.namespace.keyword: \"openshift-ovn-kubernetes\" AND labels.pod.keyword: /ovnkube-node.*/") + + elasticsearch.withTimeField('timestamp') + }, + etcd99thLatencies: { + query(metric): + elasticsearch.withAlias("") + + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: \""+ metric +"\"") + + elasticsearch.withTimeField('timestamp') + }, + etcdLeaderChanges: { + query(): + elasticsearch.withAlias("Etcd leader changes") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: etcdLeaderChangesRate") + + elasticsearch.withTimeField('timestamp') + }, + etcd99thNetworkPeerRT: { + query(): + elasticsearch.withAlias("{{labels.pod.keyword}} to {{labels.To.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + 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.Terms.withField("labels.To.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: 99thEtcdRoundTripTimeSeconds") + + elasticsearch.withTimeField('timestamp') + }, + etcdResourceUtilization: { + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Rss {{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: containerMemory* AND labels.container.keyword: etcd"), + self.base("{{labels.pod.keyword}}", "uuid.keyword: $uuid AND metricName.keyword: containerCPU* AND labels.container.keyword: etcd"), + ], + }, + readOnlyAPILatencyResource: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.verb.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('_term') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount(0) + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.Terms.withField("labels.resource.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: readOnlyAPICallsLatency AND labels.scope.keyword: resource") + + elasticsearch.withTimeField('timestamp') + }, + readOnlyAPILatencyNamespace: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.verb.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(0) + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: readOnlyAPICallsLatency AND labels.scope.keyword: namespace") + + elasticsearch.withTimeField('timestamp') + }, + readOnlyAPILatencyCluster: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.verb.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(0) + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: readOnlyAPICallsLatency AND labels.scope.keyword: cluster") + + elasticsearch.withTimeField('timestamp') + }, + readOnlyAPILatencyMutating: { + query(): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.verb.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(0) + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: mutatingAPICallsLatency") + + elasticsearch.withTimeField('timestamp') + }, + serviceSyncLatency: { + query(): + elasticsearch.withAlias("Latency") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: serviceSyncLatency") + + elasticsearch.withTimeField('timestamp') + }, + apiRequestRate: { + query(): + elasticsearch.withAlias("{{labels.verb.keyword}} {{labels.resource.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.resource.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + 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.Terms.withField("labels.verb.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('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: APIRequestRate") + + elasticsearch.withTimeField('timestamp') + }, + top5KubeletProcessByCpuUsage: { + queries(): [ + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.node.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("5"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: kubeletCPU") + + elasticsearch.withTimeField('timestamp'), + elasticsearch.withAlias("Average across workers") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: kubeletCPU") + + elasticsearch.withTimeField('timestamp'), + ], + }, + top5CrioProcessByCpuUsage: { + queries(): [ + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.node.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("5"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: crioCPU") + + elasticsearch.withTimeField('timestamp'), + elasticsearch.withAlias("Average across workers") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: crioCPU") + + elasticsearch.withTimeField('timestamp'), + ], + }, + top5KubeletRSSByMemoryUsage: { + queries(): [ + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.node.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("5"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1"), + ]) + + 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: kubeletMemory") + + elasticsearch.withTimeField('timestamp'), + elasticsearch.withAlias("Average across workers") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1"), + ]) + + 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: kubeletMemory") + + elasticsearch.withTimeField('timestamp'), + ], + }, + top5CrioRSSByMemoryUsage: { + queries(): [ + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.node.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("5"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: crioMemory") + + elasticsearch.withTimeField('timestamp'), + elasticsearch.withAlias("Average across workers") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount("1") + + 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: crioMemory") + + elasticsearch.withTimeField('timestamp'), + ], + }, + mastersContainerStats: { + query(metric): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + 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('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto'), + ]) + + 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: \""+ metric +"\" AND labels.node.keyword: $master") + + elasticsearch.withTimeField('timestamp') + }, + masterCPU: { + query(): + elasticsearch.withAlias("{{labels.mode.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.mode.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withSettings({ + "script": { + "inline": "_value*100" + } + }) + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: \"nodeCPU-Masters\" AND labels.instance.keyword: $master") + + elasticsearch.withTimeField('timestamp') + }, + masterMemory: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Utilization", "uuid.keyword: $uuid AND metricName.keyword: \"nodeMemoryUtilization-Masters\" AND labels.instance.keyword: $master"), + ], + }, + workersContainerStats: { + query(metric): + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + 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('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto'), + ]) + + 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: "+ metric +" AND labels.node.keyword: $worker") + + elasticsearch.withTimeField('timestamp') + }, + workerCPU: { + query(): + elasticsearch.withAlias("{{labels.mode.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.mode.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withSettings({ + "script": { + "inline": "_value*100" + } + }) + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: \"nodeCPU-Workers\" AND labels.instance.keyword: \"$worker\"") + + elasticsearch.withTimeField('timestamp') + }, + workerMemory: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Utilization", "uuid.keyword: $uuid AND metricName.keyword: \"nodeMemoryUtilization-Workers\" AND labels.instance.keyword: $worker"), + ], + }, + infraContainerStats: { + queries(metric): [ + elasticsearch.withAlias("{{labels.pod.keyword}}: {{labels.container.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("0"), + 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('1') + + 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('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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: \""+ metric +"\" AND labels.node.keyword: \"$infra\" AND labels.namespace.keyword: $namespace") + + elasticsearch.withTimeField('timestamp'), + elasticsearch.withAlias("") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.pod.keyword") + + elasticsearch.bucketAggs.Terms.withId("4") + + 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.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto'), + ]) + + 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: "+ metric +"-Infra AND labels.node.keyword: $infra") + + elasticsearch.withTimeField('timestamp'), + ], + }, + infraCPU: { + query(): + elasticsearch.withAlias("{{labels.mode.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.mode.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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withSettings({ + "script": { + "inline": "_value*100" + } + }) + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: \"nodeCPU-Infra\" AND labels.instance.keyword: $infra") + + elasticsearch.withTimeField('timestamp') + }, + infraMemory: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("available", "uuid.keyword: $uuid AND metricName.keyword: \"nodeMemoryAvailable-Infra\" AND labels.instance.keyword: $infra"), + self.base("Total", "uuid.keyword: $uuid AND metricName.keyword: \"nodeMemoryTotal-Infra\" AND labels.instance.keyword: $infra"), + ], + }, + aggWorkerNodeCpuUsage: { + query(): + elasticsearch.withAlias("{{labels.mode.keyword}}") + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.Terms.withField("labels.mode.keyword") + + elasticsearch.bucketAggs.Terms.withId("3") + + elasticsearch.bucketAggs.Terms.withType('terms') + + elasticsearch.bucketAggs.Terms.settings.withOrder('desc') + + elasticsearch.bucketAggs.Terms.settings.withOrderBy('1') + + elasticsearch.bucketAggs.Terms.settings.withMinDocCount("1") + + elasticsearch.bucketAggs.Terms.settings.withSize("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + elasticsearch.bucketAggs.DateHistogram.settings.withTrimEdges(0), + ]) + + elasticsearch.withMetrics([ + elasticsearch.metrics.MetricAggregationWithSettings.Average.withField("value") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withId("1") + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withSettings({ + "script": { + "inline": "_value*100" + } + }) + + elasticsearch.metrics.MetricAggregationWithSettings.Average.withType('avg'), + ]) + + elasticsearch.withQuery("uuid.keyword: $uuid AND metricName.keyword: \"nodeCPU-AggregatedWorkers\"") + + elasticsearch.withTimeField('timestamp') + }, + aggWorkerNodeMemory: { + base(alias, query): + elasticsearch.withAlias(alias) + + elasticsearch.withBucketAggs([ + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('30s') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1') + + 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(query) + + elasticsearch.withTimeField('timestamp'), + queries(): [ + self.base("Available", "uuid.keyword: $uuid AND metricName.keyword: \"nodeMemoryAvailable-AggregatedWorkers\""), + ], + }, + aggWorkerNodeContainerCpuUsage: { + query(): + elasticsearch.withAlias("") + + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto') + + elasticsearch.bucketAggs.DateHistogram.settings.withMinDocCount('1'), + ]) + + 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: containerCPU-AggregatedWorkers") + + elasticsearch.withTimeField('timestamp') + }, + aggWorkerNodeContainerMemoryUsage: { + query(): + elasticsearch.withAlias("") + + 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("10"), + elasticsearch.bucketAggs.DateHistogram.withField("timestamp") + + elasticsearch.bucketAggs.DateHistogram.withId("2") + + elasticsearch.bucketAggs.DateHistogram.withType('date_histogram') + + elasticsearch.bucketAggs.DateHistogram.settings.withInterval('auto'), + ]) + + 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: containerMemory-AggregatedWorkers") + + elasticsearch.withTimeField('timestamp') + }, +} \ No newline at end of file diff --git a/assets/kube-burner-report-ocp-wrapper/variables.libsonnet b/assets/kube-burner-report-ocp-wrapper/variables.libsonnet new file mode 100644 index 0000000..2e5ba14 --- /dev/null +++ b/assets/kube-burner-report-ocp-wrapper/variables.libsonnet @@ -0,0 +1,77 @@ +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.generalOptions.withLabel('Datasource'), + + platform: + var.query.new('platform', "{\"find\": \"terms\", \"field\": \"metadata.platform.keyword\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(2) + + var.query.selectionOptions.withMulti() + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Platform'), + + sdn: + var.query.new('sdn', "{\"find\": \"terms\", \"field\": \"metadata.sdnType.keyword\", \"query\": \"metadata.platform.keyword: $platform\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti() + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('SDN type'), + + workload: + var.query.new('workload', "{\"find\": \"terms\", \"field\": \"jobConfig.name.keyword\", \"query\": \"metadata.platform.keyword: $platform AND metadata.sdnType.keyword: $sdn\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(false) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Workload'), + + nodes: + var.query.new('nodes', "{\"find\": \"terms\", \"field\": \"metadata.totalNodes\", \"query\": \"metadata.platform.keyword: $platform AND metadata.sdnType.keyword: $sdn AND jobConfig.name.keyword: $workload\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(1) + + var.query.selectionOptions.withMulti(false) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('nodes'), + + uuid: + var.query.new('uuid', "{\"find\": \"terms\", \"field\": \"uuid.keyword\", \"query\": \"metadata.platform.keyword: $platform AND metadata.sdnType.keyword: $sdn AND jobConfig.name.keyword: $workload AND metadata.totalNodes: $nodes\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(2) + + var.query.selectionOptions.withMulti(false) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('UUID'), + + master: + var.query.new('master', "{ \"find\" : \"terms\", \"field\": \"labels.node.keyword\", \"query\": \"metricName.keyword: nodeRoles AND labels.role.keyword: master AND uuid.keyword: $uuid\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(2) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Master nodes'), + + worker: + var.query.new('worker', "{ \"find\" : \"terms\", \"field\": \"labels.node.keyword\", \"query\": \"metricName.keyword: nodeRoles AND labels.role.keyword: worker AND uuid.keyword: $uuid\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(2) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Worker nodes'), + + infra: + var.query.new('infra', "{ \"find\" : \"terms\", \"field\": \"labels.node.keyword\", \"query\": \"metricName.keyword: nodeRoles AND labels.role.keyword: infra AND uuid.keyword: $uuid\"}") + + var.query.withDatasourceFromVariable(self.Datasource) + + var.query.withRefresh(2) + + var.query.selectionOptions.withMulti(true) + + var.query.selectionOptions.withIncludeAll(false) + + var.query.generalOptions.withLabel('Infra nodes'), + + latencyPercentile: + var.custom.new('latencyPercentile', ['P99', 'P95', 'P50'],) + + var.custom.generalOptions.withLabel('Latency percentile'), +} \ No newline at end of file diff --git a/dittybopper/syncer/entrypoint.py b/dittybopper/syncer/entrypoint.py index e9d607a..8142ed3 100644 --- a/dittybopper/syncer/entrypoint.py +++ b/dittybopper/syncer/entrypoint.py @@ -13,9 +13,10 @@ class GrafanaOperations: """ This class is responsible for Grafana operations """ - def __init__(self, grafana_url: str, input_directory: str): + def __init__(self, grafana_url: str, input_directory: str, git_commit_hash: str): self.grafana_url = grafana_url self.input_directory = input_directory + self.git_commit_hash = git_commit_hash self.dashboards = defaultdict(list) self.folder_map = dict() self.logger = logging.getLogger(__name__) @@ -102,6 +103,10 @@ def create_dashboards(self): for folder_id, files in self.dashboards.items(): for json_file in set(files): dashboard_json = self.read_dashboard_json(json_file) + if "tags" in dashboard_json.keys(): + dashboard_json["tags"].append(self.git_commit_hash) + else: + dashboard_json["tags"] = self.git_commit_hash try: response = requests.post( f"{self.grafana_url}/api/dashboards/db", @@ -122,7 +127,7 @@ def create_dashboards(self): raise Exception(f"Error creating dashboard '{dashboard_json['title']}' in folder '{folder_id}'. Message: {e}") if __name__ == '__main__': - grafana_operations = GrafanaOperations(os.environ.get("GRAFANA_URL"), os.environ.get("INPUT_DIR")) + grafana_operations = GrafanaOperations(os.environ.get("GRAFANA_URL"), os.environ.get("INPUT_DIR"), os.environ.get("GIT_COMMIT_HASH")) grafana_operations.fetch_all_dashboards() grafana_operations.create_dashboards() while True: diff --git a/templates/CPT/kube-burner-report-ocp-wrapper-v2.jsonnet b/templates/CPT/kube-burner-report-ocp-wrapper-v2.jsonnet new file mode 100644 index 0000000..22f9f22 --- /dev/null +++ b/templates/CPT/kube-burner-report-ocp-wrapper-v2.jsonnet @@ -0,0 +1,149 @@ +local panels = import '../../assets/kube-burner-report-ocp-wrapper/panels.libsonnet'; +local queries = import '../../assets/kube-burner-report-ocp-wrapper/queries.libsonnet'; +local variables = import '../../assets/kube-burner-report-ocp-wrapper/variables.libsonnet'; +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; + +g.dashboard.new('Kube-burner Report - OCP wrapper') ++ g.dashboard.withDescription(||| + Dashboard for kube-burner OCP wrapper +|||) ++ g.dashboard.withTags('kube-burner') ++ g.dashboard.time.withFrom('now-12h') ++ g.dashboard.time.withTo('now') ++ 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(false) ++ g.dashboard.graphTooltip.withSharedCrosshair() ++ g.dashboard.withVariables([ + variables.Datasource, + variables.platform, + variables.sdn, + variables.workload, + variables.nodes, + variables.uuid, + variables.master, + variables.worker, + variables.infra, + variables.latencyPercentile, +]) ++ g.dashboard.withPanels([ + panels.stat.withLastNotNullCalcs('Node count', 'none', queries.nodeCount.query(), { x: 0, y: 0, w: 4, h: 3 }), + panels.stat.withLastNotNullCalcs('', '', queries.aggregatesCount.queries(), { x: 4, y: 0, w: 12, h: 3 }), + panels.stat.withFieldSummary('OpenShift version', '', '/^metadata\\.ocpVersion$/', queries.openshiftVersion.query(), { x: 16, y: 0, w: 6, h: 3 }), + panels.stat.withFieldSummary('Etcd version', '', '/^labels\\.cluster_version$/', queries.openshiftVersion.query(), { x: 22, y: 0, w: 2, h: 3 }), + panels.table.withJobSummary('', '', queries.jobSummary.query(), { x: 0, y: 3, w: 24, h: 3 }), + panels.table.withClusterMetadata('', '', queries.clusterMetadata.query(), { x: 0, y: 6, w: 24, h: 3 }), + panels.table.withAlerts('Alerts', '', queries.alerts.query(), { x: 0, y: 9, w: 24, h: 4 }), + g.panel.row.new('Cluster status') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.timeSeries.withMeanMax('Masters CPU utilization', 'percent', queries.mastersCPUUtilization.queries(), { x: 0, y: 14, w: 12, h: 9 }, -1), + panels.timeSeries.sortByMin('Masters Memory utilization', 'bytes', queries.mastersMemoryUtilization.queries(), { x: 12, y: 14, w: 12, h: 9 }, -1), + panels.timeSeries.sortMaxWithRightLegend('Node status summary', 'short', queries.nodeStatusSummary.query(), { x: 0, y: 23, w: 12, h: 8 }, null), + panels.timeSeries.maxWithBottomLegend('Pod status summary', 'none', queries.podStatusSummary.query(), { x: 12, y: 23, w: 12, h: 8 }, null), + panels.timeSeries.kupeApiCustomOverrides('Kube-apiserver usage', 'percent', queries.kubeApiServerUsage.queries(), { x: 0, y: 31, w: 12, h: 9 }, null), + panels.timeSeries.kupeApiAverageCustomOverrides('Average kube-apiserver usage', 'percent', queries.averageKubeApiServerUsage.queries(), { x: 12, y: 31, w: 12, h: 9 }, null), + panels.timeSeries.activeKubeControllerManagerOverrides('Active Kube-controller-manager usage', 'percent', queries.activeKubeControllerManagerUsage.queries(), { x: 0, y: 40, w: 12, h: 9 }, null), + panels.timeSeries.kubeSchedulerUsageOverrides('Kube-scheduler usage', 'percent', queries.kubeSchedulerUsage.queries(), { x: 12, y: 40, w: 12, h: 9 }, null), + ]), + g.panel.row.new('Pod latency stats') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.timeSeries.sortByMeanCommon('Average pod latency', 'ms', queries.averagePodLatency.query(), { x: 0, y: 13, w: 12, h: 8 }, -1), + panels.stat.withMeanThresholds('Pod latencies summary $latencyPercentile', 'ms', queries.podLatenciesSummary.query(), { x: 12, y: 15, w: 12, h: 8 }), + panels.table.withLatencyTableOverrides('Pod conditions latency', 'ms', queries.podConditionsLatency.query(), { x: 0, y: 23, w: 24, h: 10 }), + panels.timeSeries.sortByMax('Top 10 Container runtime network setup latency', 'µs', queries.top10ContainerRuntimeNetworkSetupLatency.query(), { x: 0, y: 33, w: 12, h: 9 }, -1), + panels.timeSeries.withMeanMax('Scheduling throughput', 'reqps', queries.schedulingThroughput.query(), { x: 12, y: 33, w: 12, h: 9 }, -1), + ]), + g.panel.row.new('OVNKubernetes') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.timeSeries.sortByMean('ovnkube-master pods CPU usage', 'percent', queries.ovnKubeMasterPodStats.queries('containerCPU'), { x: 0, y: 16, w: 12, h: 9 }, null), + panels.timeSeries.sortByMax('ovnkube-master pods Memory usage', 'bytes', queries.ovnKubeMasterPodStats.queries('containerMemory'), { x: 12, y: 16, w: 12, h: 9 }, null), + panels.timeSeries.sortByMean('ovnkube-master CPU usage', 'percent', queries.ovnKubeMasterStats.queries('containerCPU'), { x: 0, y: 25, w: 12, h: 8 }, null), + panels.timeSeries.sortByMaxCommon('ovnkube-master Memory Usage', 'bytes', queries.ovnKubeMasterStats.queries('containerMemory'), { x: 12, y: 25, w: 12, h: 8 }, null), + panels.timeSeries.sortByMean('ovnkube-node pods CPU Usage', 'percent', queries.ovnKubeNodePodStats.queries('containerCPU'), { x: 0, y: 33, w: 12, h: 8 }, null), + panels.timeSeries.sortByMean('ovnkube-node pods Memory Usage', 'bytes', queries.ovnKubeNodePodStats.queries('containerMemory'), { x: 12, y: 33, w: 12, h: 8 }, null), + panels.timeSeries.sortByMax('ovn-controller CPU Usage', 'percent', queries.ovnControllerStats.query('containerCPU'), { x: 0, y: 41, w: 12, h: 8 }, null), + panels.timeSeries.sortByMax('ovn-controller Memory Usage', 'bytes', queries.ovnControllerStats.query('containerMemory'), { x: 12, y: 41, w: 12, h: 8 }, null), + panels.timeSeries.withMeanMax('Aggregated OVNKube-master containers CPU', 'percent', queries.aggregatedOVNKubeMasterStats.queries('containerCPU'), { x: 0, y: 49, w: 12, h: 14 }, null), + panels.timeSeries.withMeanMax('Aggregated OVNKube-master containers memory', 'bytes', queries.aggregatedOVNKubeMasterStats.queries('containerMemory'), { x: 12, y: 49, w: 12, h: 14 }, null), + panels.timeSeries.withMeanMax('Aggregated OVNKube-node containers CPU', 'percent', queries.aggregatedOVNKubeNodeStats.query('containerCPU'), { x: 0, y: 63, w: 12, h: 14 }, null), + panels.timeSeries.sortByMeanCommon('Aggregated OVNKube-node containers Memory', 'bytes', queries.aggregatedOVNKubeNodeStats.query('containerMemory'), { x: 12, y: 63, w: 12, h: 14 }, null), + ]), + 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.timeSeries.etcd99thDiskWalLatencyOverrides('etcd 99th disk WAL fsync latency', 's', queries.etcd99thLatencies.query('99thEtcdDiskWalFsyncDurationSeconds'), { x: 0, y: 17, w: 12, h: 9 }, null), + panels.timeSeries.etcd99thCommitLatencyOverrides('etcd 99th disk backend commit latency', 's', queries.etcd99thLatencies.query('99thEtcdDiskBackendCommitDurationSeconds'), { x: 12, y: 17, w: 12, h: 9 }, null), + panels.timeSeries.base('Etcd leader changes', 'none', queries.etcdLeaderChanges.query(), { x: 0, y: 26, w: 12, h: 9 }, null), + panels.timeSeries.etcd99thNetworkPeerRTOverrides('Etcd 99th network peer roundtrip time', 's', queries.etcd99thNetworkPeerRT.query(), { x: 12, y: 26, w: 12, h: 9 }, null), + panels.timeSeries.etcdResouceUtilizationOverrides('Etcd resource utilization', 'percent', queries.etcdResourceUtilization.queries(), { x: 0, y: 35, w: 12, h: 9 }, null), + ]), + g.panel.row.new('API and Kubeproxy') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.timeSeries.readOnlyAPIRequestp99ResourceOverrides('Read Only API request P99 latency - resource scoped', 's', queries.readOnlyAPILatencyResource.query(), { x: 0, y: 18, w: 12, h: 8 }, -1), + panels.timeSeries.readOnlyAPIRequestp99NamespaceOverrides('Read Only API request P99 latency - namespace scoped', 's', queries.readOnlyAPILatencyNamespace.query(), { x: 12, y: 18, w: 12, h: 8 }, -1), + panels.timeSeries.readOnlyAPIRequestp99ClusterOverrides('Read Only API request P99 latency - cluster scoped', 's', queries.readOnlyAPILatencyCluster.query(), { x: 0, y: 26, w: 12, h: 8 }, -1), + panels.timeSeries.readOnlyAPIRequestp99MutatingOverrides('Mutating API request P99 latency', 's', queries.readOnlyAPILatencyMutating.query(), { x: 12, y: 26, w: 12, h: 8 }, -1), + panels.timeSeries.base('Service sync latency', 's', queries.serviceSyncLatency.query(), { x: 0, y: 34, w: 12, h: 10 }, null), + panels.timeSeries.sortByMax('API request rate', 'reqps', queries.apiRequestRate.query(), { x: 12, y: 34, w: 12, h: 10 }, -1), + ]), + g.panel.row.new('Cluster Kubelet & CRI-O') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 24, h: 1 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withPanels([ + panels.timeSeries.meanWithRightLegendCommons('Top 5 Kubelet process by CPU usage', 'percent', queries.top5KubeletProcessByCpuUsage.queries(), { x: 0, y: 19, w: 12, h: 8 }, null), + panels.timeSeries.meanWithRightLegendCommons('Top 5 CRI-O process by CPU usage', 'percent', queries.top5CrioProcessByCpuUsage.queries(), { x: 12, y: 19, w: 12, h: 8 }, null), + panels.timeSeries.maxMeanWithRightLegend('Top 5 Kubelet RSS by memory usage', 'bytes', queries.top5KubeletRSSByMemoryUsage.queries(), { x: 0, y: 27, w: 12, h: 8 }, -1), + panels.timeSeries.maxMeanWithRightLegend('Top 5 CRI-O RSS by memory usage', 'bytes', queries.top5CrioRSSByMemoryUsage.queries(), { x: 12, y: 27, w: 12, h: 8 }, null), + ]), + g.panel.row.new('Master: $master') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 0, h: 8 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withRepeat('master') + + g.panel.row.withPanels([ + panels.timeSeries.sortByMax('Container CPU usage $master', 'percent', queries.mastersContainerStats.query('containerCPU'), { x: 0, y: 20, w: 12, h: 9 }, null), + panels.timeSeries.maxWithBottomLegend('Container RSS memory $master', 'bytes', queries.mastersContainerStats.query('containerMemory'), { x: 12, y: 20, w: 12, h: 9 }, null), + panels.timeSeries.withCommonAggregationsRightPlacement('CPU $master', 'percent', queries.masterCPU.query(), { x: 0, y: 29, w: 12, h: 9 }, null), + panels.timeSeries.allWithRightLegend('Memory $master', 'bytes', queries.masterMemory.queries(), { x: 12, y: 29, w: 12, h: 9 }, null), + ]), + g.panel.row.new('Worker: $worker') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 0, h: 8 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withRepeat('worker') + + g.panel.row.withPanels([ + panels.timeSeries.sortByMax('Container CPU usage $worker', 'percent', queries.workersContainerStats.query('containerCPU'), { x: 0, y: 21, w: 12, h: 9 }, null), + panels.timeSeries.withMeanMax('Container RSS memory $worker', 'bytes', queries.workersContainerStats.query('containerMemory'), { x: 12, y: 21, w: 12, h: 9 }, null), + panels.timeSeries.workerCPUCustomOverrides('CPU $worker', 'percent', queries.workerCPU.query(), { x: 0, y: 30, w: 12, h: 8 }, null), + panels.timeSeries.maxWithRightLegend('Memory $worker', 'bytes', queries.workerMemory.queries(), { x: 12, y: 30, w: 12, h: 8 }, null), + ]), + g.panel.row.new('Infra: $infra') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 0, h: 8 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withRepeat('infra') + + g.panel.row.withPanels([ + panels.timeSeries.sortByMean('Container CPU usage $infra', 'percent', queries.infraContainerStats.queries('containerCPU'), { x: 0, y: 31, w: 12, h: 9 }, null), + panels.timeSeries.sortByMax('Container RSS memory $infra', 'bytes', queries.infraContainerStats.queries('containerMemory'), { x: 12, y: 31, w: 12, h: 9 }, null), + panels.timeSeries.meanWithRightLegend('CPU $infra', 'percent', queries.infraCPU.query(), { x: 0, y: 31, w: 12, h: 9 }, null), + panels.timeSeries.minMaxWithRightLegend('Memory $infra', 'bytes', queries.infraMemory.queries(), { x: 12, y: 31, w: 12, h: 9 }, null), + ]), + g.panel.row.new('Aggregated worker nodes usage (only in aggregated metrics profile)') + + g.panel.row.withGridPos({ x: 0, y: 14, w: 0, h: 8 }) + + g.panel.row.withCollapsed(true) + + g.panel.row.withRepeat('_infra_node') + + g.panel.row.withPanels([ + panels.timeSeries.meanWithRightLegend('Avg CPU usage', 'percent', queries.aggWorkerNodeCpuUsage.query(), { x: 0, y: 23, w: 12, h: 9 }, -1), + panels.timeSeries.maxWithRightLegend('Avg Memory', 'bytes', queries.aggWorkerNodeMemory.queries(), { x: 12, y: 23, w: 12, h: 9 }, null), + panels.timeSeries.sortByMax('container CPU usage', 'percent', queries.aggWorkerNodeContainerCpuUsage.query(), { x: 0, y: 32, w: 12, h: 9 }, -1), + panels.timeSeries.sortByMax('Container memory RSS', 'bytes', queries.aggWorkerNodeContainerMemoryUsage.query(), { x: 12, y: 32, w: 12, h: 9 }, null), + ]), +]) diff --git a/templates/jsonnetfile.json b/templates/jsonnetfile.json new file mode 100644 index 0000000..2414c86 --- /dev/null +++ b/templates/jsonnetfile.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-latest" + } + }, + "version": "main" + } + ], + "legacyImports": true +} diff --git a/templates/jsonnetfile.lock.json b/templates/jsonnetfile.lock.json new file mode 100644 index 0000000..d4b9d5c --- /dev/null +++ b/templates/jsonnetfile.lock.json @@ -0,0 +1,46 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-latest" + } + }, + "version": "9087f21f41936c32967e4e3ae164627ba4055fed", + "sum": "sVzVlSLbxPkAurwO19YERigLMmRfVsViMcWC0gkTTqU=" + }, + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-v10.0.0" + } + }, + "version": "9087f21f41936c32967e4e3ae164627ba4055fed", + "sum": "bWMuE3sTMnEFFwYmmwugyX+gjNsGea6NDwWxgzB19JQ=" + }, + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/docsonnet.git", + "subdir": "doc-util" + } + }, + "version": "fd8de9039b3c06da77d635a3a8289809a5bfb542", + "sum": "mFebrE9fhyAKW4zbnidcjVFupziN5LPA/Z7ii94uCzs=" + }, + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/xtd.git", + "subdir": "" + } + }, + "version": "0256a910ac71f0f842696d7bca0bf01ea77eb654", + "sum": "zBOpb1oTNvXdq9RF6yzTHill5r1YTJLBBoqyx4JYtAg=" + } + ], + "legacyImports": false +}