refactor: Use querybuilder for deployment queries and implement sorting for deployments table

tiithansen · tiithansen · commit 12280b8144a5 · 2024-06-21T11:19:20.000+03:00
diff --git a/src/metrics/metrics.ts b/src/metrics/metrics.ts
@@ -207,6 +207,13 @@ export const Metrics = {
         }
     },
     // Deployments
+    kubeDeploymentCreated: {
+        name: 'kube_deployment_created',
+        labels:{
+            namespace: 'namespace',
+            deployment: 'deployment',
+        }
+    },
     kubeDeploymentStatusReplicas: {
         name: 'kube_deployment_status_replicas',
         labels:{
diff --git a/src/pages/Workloads/tabs/Deployments/DeploymentExpandedRow.tsx b/src/pages/Workloads/tabs/Deployments/DeploymentExpandedRow.tsx
@@ -27,7 +27,6 @@ export function buildExpandedRowScene(row: TableRow) {
       children: [
         new SceneFlexLayout({
           direction: 'row',
-          height: 300,
           children: [
             getPodsScene(staticLabelFilters, false, false)
           ]
diff --git a/src/pages/Workloads/tabs/Deployments/Deployments.tsx b/src/pages/Workloads/tabs/Deployments/Deployments.tsx
@@ -29,6 +29,7 @@ const columns: Array<Column<TableRow>> = [
             enabled: true,
             type: 'label',
             local: true,
+            compare: (a: TableRow, b: TableRow, direction) => direction === 'asc' ? a.deployment.localeCompare(b.deployment) : b.deployment.localeCompare(a.deployment)
         }
     },
     { 
@@ -42,6 +43,7 @@ const columns: Array<Column<TableRow>> = [
             enabled: true,
             type: 'label',
             local: true,
+            compare: (a: TableRow, b: TableRow, direction) => direction === 'asc' ? a.namespace.localeCompare(b.namespace) : b.namespace.localeCompare(a.namespace)
         }
     },
     {
@@ -65,7 +67,7 @@ const columns: Array<Column<TableRow>> = [
         sortingConfig: {
             enabled: true,
             type: 'value',
-            local: true,
+            local: false,
         }
     }
 ]
@@ -74,8 +76,6 @@ const serieMatcherPredicate = (row: TableRow) => (value: any) => value.deploymen
 
 function asyncRowMapper(row: TableRow, asyncRowData: any) {
     
-    row.deployment = row.owner_name
-
     const total = getSeriesValue(asyncRowData, 'replicas', serieMatcherPredicate(row))
     const ready = getSeriesValue(asyncRowData, 'replicas_ready', serieMatcherPredicate(row))
 
diff --git a/src/pages/Workloads/tabs/Deployments/Queries.ts b/src/pages/Workloads/tabs/Deployments/Queries.ts
@@ -4,70 +4,76 @@ import { Metrics } from "metrics/metrics";
 import { TableRow } from "./types";
 import { QueryBuilder, ColumnSortingConfig } from "components/AsyncTable";
 import { SortingState } from "common/sortingHelpers";
+import { MatchOperators, OperatorAndValue, PromQL, PromQLExpression } from "common/promql";
 
-function createAlertsQuery(cluster?: string, deployments?: string) {
-    return `
-        ALERTS{
-            cluster="${cluster}",
-            ${deployments ? `deployment=~"${deployments}",` : ''}
-            alertstate="firing",
-        }
-        * ignoring(alertstate) group_right(alertstate) ALERTS_FOR_STATE{
-            cluster="${cluster}",
-            ${deployments ? `deployment=~"${deployments}",` : ''}
-        }
-    `
-}
+function createAlertsQuery(cluster: string, additionalLabels: Record<string, OperatorAndValue>) {
 
-function createReplicasQuery(cluster?: string, deployments?: string) {
-    return `
-        max(
-            ${Metrics.kubeDeploymentStatusReplicas.name}{
-                ${Metrics.kubeDeploymentStatusReplicas.labels.deployment}=~"${deployments}",
-                cluster="${cluster}"
-            }
-        ) by (
-            ${Metrics.kubeDeploymentStatusReplicas.labels.deployment}, 
-            ${Metrics.kubeDeploymentStatusReplicas.labels.namespace}
+    return PromQL.metric('ALERTS')
+        .withLabelEquals('cluster', cluster)
+        .withLabels(additionalLabels)
+        .withLabelEquals('alertstate', 'firing')
+        .multiply()
+        .ignoring(['alertstate'])
+        .groupRight(
+            ['alertstate'],
+            PromQL.metric('ALERTS_FOR_STATE')
+                .withLabelEquals('cluster', cluster)
+                .withLabels(additionalLabels)
         )
-    `
 }
 
-function createReplicasReadyQuery(cluster?: string, deployments?: string) {
-    return `
-        max(
-            ${Metrics.kubeDeploymentStatusReplicasReady.name}{
-                ${Metrics.kubeDeploymentStatusReplicasReady.labels.deployment}=~"${deployments}",
-                cluster="${cluster}"
-            }
-        ) by (
-            ${Metrics.kubeDeploymentStatusReplicasReady.labels.deployment},
-            ${Metrics.kubeDeploymentStatusReplicasReady.labels.namespace}
-        )
-    `
+function createReplicasQuery(cluster: string, additionalLabels: Record<string, OperatorAndValue>) {
+
+    return PromQL.max(
+        PromQL.metric(Metrics.kubeDeploymentStatusReplicas.name)
+            .withLabels(additionalLabels)
+            .withLabelEquals('cluster', cluster)
+    ).by(
+        Metrics.kubeDeploymentStatusReplicas.labels.deployment,
+        Metrics.kubeDeploymentStatusReplicas.labels.namespace
+    )
+}
+
+function createReplicasReadyQuery(cluster: string, deployments: string) {
+
+    return PromQL.max(
+        PromQL.metric(Metrics.kubeDeploymentStatusReplicasReady.name)
+            .withLabelMatches(Metrics.kubeDeploymentStatusReplicasReady.labels.deployment, deployments)
+            .withLabelEquals('cluster', cluster)
+    ).by(
+        Metrics.kubeDeploymentStatusReplicasReady.labels.deployment,
+        Metrics.kubeDeploymentStatusReplicasReady.labels.namespace
+    )
 }
 
 function createRowQueries(rows: TableRow[], sceneVariables: SceneVariables) {
 
     const deployments = rows.map(row => row.deployment).join('|');
     const cluster = resolveVariable(sceneVariables, 'cluster');
 
+    const additionalLabels = {
+        'deployment': {
+            operator: MatchOperators.MATCHES,
+            value: deployments
+        }
+    }
+
     return [
         {
             refId: 'alerts',
-            expr: createAlertsQuery(cluster?.toString(), deployments),
+            expr: createAlertsQuery(cluster?.toString()!, additionalLabels).stringify(),
             instant: true,
             format: 'table'
         },
         {
             refId: 'replicas',
-            expr: createReplicasQuery(cluster?.toString(), deployments),
+            expr: createReplicasQuery(cluster?.toString()!, additionalLabels).stringify(),
             instant: true,
             format: 'table'
         },
         {
             refId: 'replicas_ready',
-            expr: createReplicasReadyQuery(cluster?.toString(), deployments),
+            expr: createReplicasReadyQuery(cluster?.toString()!, deployments).stringify(),
             instant: true,
             format: 'table'
         },
@@ -77,18 +83,58 @@ function createRowQueries(rows: TableRow[], sceneVariables: SceneVariables) {
 export class DeploymentQueryBuilder implements QueryBuilder<TableRow> {
     rootQueryBuilder(variables: SceneVariableSet | SceneVariables, sorting: SortingState, sortingConfig?: ColumnSortingConfig<TableRow>) {
 
-        const query = 
-            `group(
-                ${Metrics.kubeReplicasetOwner.name}{
-                    cluster="$cluster",
-                    ${Metrics.kubeReplicasetOwner.labels.namespace}=~"$namespace",
-                    ${Metrics.kubeReplicasetOwner.labels.ownerName}=~".*$search.*",
-                    ${Metrics.kubeReplicasetOwner.labels.ownerKind}="Deployment"
-                }
-            ) by (
-                ${Metrics.kubeReplicasetOwner.labels.ownerName},
-                ${Metrics.kubeReplicasetOwner.labels.namespace}
-            )`
+        const baseQuery = PromQL.group(
+            PromQL.metric(Metrics.kubeDeploymentCreated.name)
+                .withLabelEquals('cluster', '$cluster')
+                .withLabelMatches(Metrics.kubeDeploymentCreated.labels.namespace, '$namespace')
+                .withLabelMatches(Metrics.kubeDeploymentCreated.labels.deployment, '.*$search.*')
+        ).by(
+            Metrics.kubeDeploymentCreated.labels.deployment,
+            Metrics.kubeDeploymentCreated.labels.namespace
+        )
+
+        const remoteSort = sortingConfig && sortingConfig.local === false
+
+        let finalQuery: PromQLExpression = baseQuery;
+        if (remoteSort) {
+            switch (sorting.columnId) {
+                case 'alerts':
+                    finalQuery = PromQL.sort(
+                        sorting.direction,
+                        baseQuery
+                            .multiply()
+                            .on(['namespace', 'deployment'])
+                            .groupRight(
+                                [],
+                                PromQL.count(
+                                    createAlertsQuery('$cluster', {
+                                        'deployment': {
+                                            operator: MatchOperators.NOT_EQUALS,
+                                            value: ''
+                                        }
+                                    })
+                                ).by('namespace', 'deployment')
+                            ).or(
+                                baseQuery.multiply().withScalar(0)
+                            )
+                        )
+                    break;
+                case 'replicas':
+                    finalQuery = PromQL.sort(
+                        sorting.direction,
+                        baseQuery
+                            .multiply()
+                            .on(['namespace', 'deployment'])
+                            .groupRight(
+                                [],
+                                createReplicasQuery('$cluster', {})
+                            ).or(
+                                baseQuery.multiply().withScalar(0)
+                            )
+                        )
+                    break;
+            }
+        }
 
         return new SceneQueryRunner({
             datasource: {
@@ -98,7 +144,7 @@ export class DeploymentQueryBuilder implements QueryBuilder<TableRow> {
             queries: [
                 {
                     refId: 'deployments',
-                    expr: query,
+                    expr: finalQuery.stringify(),
                     instant: true,
                     format: 'table'
                 },

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,6 @@ export function buildExpandedRowScene(row: TableRow) {`
`27`	`27`	`children: [`
`28`	`28`	`new SceneFlexLayout({`
`29`	`29`	`direction: 'row',`
`30`		`- height: 300,`
`31`	`30`	`children: [`
`32`	`31`	`getPodsScene(staticLabelFilters, false, false)`
`33`	`32`	`]`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ const columns: Array<Column<TableRow>> = [`
`29`	`29`	`enabled: true,`
`30`	`30`	`type: 'label',`
`31`	`31`	`local: true,`
	`32`	`+ compare: (a: TableRow, b: TableRow, direction) => direction === 'asc' ? a.deployment.localeCompare(b.deployment) : b.deployment.localeCompare(a.deployment)`
`32`	`33`	`}`
`33`	`34`	`},`
`34`	`35`	`{`
`@@ -42,6 +43,7 @@ const columns: Array<Column<TableRow>> = [`
`42`	`43`	`enabled: true,`
`43`	`44`	`type: 'label',`
`44`	`45`	`local: true,`
	`46`	`+ compare: (a: TableRow, b: TableRow, direction) => direction === 'asc' ? a.namespace.localeCompare(b.namespace) : b.namespace.localeCompare(a.namespace)`
`45`	`47`	`}`
`46`	`48`	`},`
`47`	`49`	`{`
`@@ -65,7 +67,7 @@ const columns: Array<Column<TableRow>> = [`
`65`	`67`	`sortingConfig: {`
`66`	`68`	`enabled: true,`
`67`	`69`	`type: 'value',`
`68`		`- local: true,`
	`70`	`+ local: false,`
`69`	`71`	`}`
`70`	`72`	`}`
`71`	`73`	`]`
`@@ -74,8 +76,6 @@ const serieMatcherPredicate = (row: TableRow) => (value: any) => value.deploymen`
`74`	`76`
`75`	`77`	`function asyncRowMapper(row: TableRow, asyncRowData: any) {`
`76`	`78`
`77`		`- row.deployment = row.owner_name`
`78`		`-`
`79`	`79`	`const total = getSeriesValue(asyncRowData, 'replicas', serieMatcherPredicate(row))`
`80`	`80`	`const ready = getSeriesValue(asyncRowData, 'replicas_ready', serieMatcherPredicate(row))`
`81`	`81`