chore: List rest of the used metrics to separate file

tiithansen · Jun 7, 2024 · 40074d1 · 40074d1
1 parent 2efbc67
commit 40074d1
Show file tree

Hide file tree

Showing 6 changed files with 237 additions and 241 deletions.
diff --git a/src/metrics/metrics.ts b/src/metrics/metrics.ts
@@ -38,6 +38,7 @@ export const Metrics = {
             pod: 'pod',
             container: 'container',
             resource: 'resource',
+            node: 'node',
         }
     },
     kubePodContainerResourceLimits: {
@@ -81,6 +82,38 @@ export const Metrics = {
             container: 'container',
         }
     },
+    containerCpuCfsThrottledPeriodsTotal: {
+        name: 'container_cpu_cfs_throttled_periods_total',
+        labels:{
+            namespace: 'namespace',
+            pod: 'pod',
+            container: 'container',
+        }
+    },
+    containerCpuCfsPeriodsTotal: {
+        name: 'container_cpu_cfs_periods_total',
+        labels:{
+            namespace: 'namespace',
+            pod: 'pod',
+            container: 'container',
+        }
+    },
+    containerNetworkReceiveBytesTotal: {
+        name: 'container_network_receive_bytes_total',
+        labels:{
+            namespace: 'namespace',
+            pod: 'pod',
+            container: 'container',
+        }
+    },
+    containerNetworkTransmitBytesTotal: {
+        name: 'container_network_transmit_bytes_total',
+        labels:{
+            namespace: 'namespace',
+            pod: 'pod',
+            container: 'container',
+        }
+    },
     // StatefulSets
     kubeStatefulsetLabels: {
         name: 'kube_statefulset_labels',
@@ -212,4 +245,40 @@ export const Metrics = {
             cronJob: 'cronjob',
         }
     },
+    // Nodes
+    kubeNodeInfo: {
+        name: 'kube_node_info',
+        labels:{
+            node: 'node',
+            internalIP: 'internal_ip',
+        }
+    },
+    machineCpuCores: {
+        name: 'machine_cpu_cores',
+        labels:{
+            node: 'node',
+        }
+    },
+    nodeMemoryMemTotalBytes: {
+        name: 'node_memory_MemTotal_bytes',
+        labels:{
+            node: 'node',
+            instance: 'instance',
+        }
+    },
+    nodeMemoryMemAvailableBytes: {
+        name: 'node_memory_MemAvailable_bytes',
+        labels:{
+            node: 'node',
+            instance: 'instance',
+        }
+    },
+    nodeCpuSecondsTotal: {
+        name: 'node_cpu_seconds_total',
+        labels:{
+            node: 'node',
+            mode: 'mode',
+            instance: 'instance',
+        }
+    },
 }
diff --git a/src/pages/Clusters/tabs/Nodes/Nodes.tsx b/src/pages/Clusters/tabs/Nodes/Nodes.tsx
@@ -11,7 +11,6 @@ import {
     TextBoxVariable,
     VariableValueSelectors,
     SceneVariableSet,
-    QueryVariable,
 } from '@grafana/scenes';
 import React, { useEffect, useMemo } from 'react';
 import { DataFrameView } from '@grafana/data';
@@ -20,23 +19,13 @@ import { createRowQueries } from './Queries';
 import { asyncQueryRunner } from 'pages/Workloads/queryHelpers';
 import { buildExpandedRowScene } from './NodeExpandedRowScene';
 import { getSeriesValue } from 'pages/Workloads/seriesHelpers';
-import { resolveVariable } from 'pages/Workloads/variableHelpers';
+import { createClusterVariable, resolveVariable } from 'pages/Workloads/variableHelpers';
 import { LinkCell } from 'pages/Workloads/components/LinkCell';
 import { CellContext } from '@tanstack/react-table';
 import { FormattedCell, TextColor } from 'pages/Workloads/components/FormattedCell';
+import { Metrics } from 'metrics/metrics';
 
-const clusterVariable = new QueryVariable({
-    name: 'cluster',
-    label: 'Cluster',
-    datasource: {
-        uid: '$datasource',
-        type: 'prometheus',
-    },
-    query: {
-      refId: 'cluster',
-      query: 'label_values(cluster)',
-    }
-});
+const clusterVariable = createClusterVariable();
 
 const searchVariable = new TextBoxVariable({
     name: 'search',
@@ -54,11 +43,15 @@ const nodesQueryRunner = new SceneQueryRunner({
             refId: 'nodes',
             expr: `
                 group(
-                    kube_node_info{
+                    ${Metrics.kubeNodeInfo.name}{
                         cluster="$cluster",
-                        node=~".*$search.*"
+                        ${Metrics.kubeNodeInfo.labels.node}=~".*$search.*"
                     }
-                ) by (internal_ip, node, cluster)`,
+                ) by (
+                    ${Metrics.kubeNodeInfo.labels.internalIP},
+                    ${Metrics.kubeNodeInfo.labels.node},
+                    cluster
+                )`,
             instant: true,
             format: 'table'
         },
@@ -262,7 +255,7 @@ class TableViz extends SceneObjectBase<TableVizState> {
                 row.cpu = {
                     usage: getSeriesValue(asyncRowData, 'cpu_usage', serieMatcherPredicate(row)),
                     requests: getSeriesValue(asyncRowData, 'cpu_requests', serieMatcherByNodeNamePredicate(row)),
-                    cores: getSeriesValue(asyncRowData, 'cores', serieMatcherPredicate(row))
+                    cores: getSeriesValue(asyncRowData, 'cores', serieMatcherByNodeNamePredicate(row))
                 }
 
                 row.pod_count = getSeriesValue(asyncRowData, 'pod_count', serieMatcherByNodeNamePredicate(row))

diff --git a/src/pages/Clusters/tabs/Nodes/Queries.tsx b/src/pages/Clusters/tabs/Nodes/Queries.tsx
@@ -1,5 +1,6 @@
 import { SceneVariables } from "@grafana/scenes";
 import { resolveVariable } from "pages/Workloads/variableHelpers";
+import { Metrics } from "metrics/metrics";
 
 export function createRowQueries(nodes: string, nodeNames: string, sceneVariables: SceneVariables) {
 
@@ -10,87 +11,91 @@ export function createRowQueries(nodes: string, nodeNames: string, sceneVariable
             refId: 'memory_total',
             expr: `
                 max(
-                    node_memory_MemTotal_bytes{
-                        instance=~"${nodes}",
+                    ${Metrics.nodeMemoryMemTotalBytes.name}{
+                        ${Metrics.nodeMemoryMemTotalBytes.labels.instance}=~"${nodes}",
                         cluster="${cluster}"
                     }
-                ) by (instance, cluster)`,
+                ) by (
+                    ${Metrics.nodeMemoryMemTotalBytes.labels.instance},
+                    cluster
+                )`,
             instant: true,
             format: 'table'
        },
        {
             refId: 'memory_free',
             expr: `
                 max(
-                    node_memory_MemAvailable_bytes{
-                        instance=~"${nodes}",
+                    ${Metrics.nodeMemoryMemAvailableBytes.name}{
+                        ${Metrics.nodeMemoryMemAvailableBytes.labels.instance}=~"${nodes}",
                         cluster="${cluster}"
                     }
-                ) by (instance, cluster)`,
+                ) by (
+                    ${Metrics.nodeMemoryMemAvailableBytes.labels.instance},
+                    cluster
+                )`,
             instant: true,
             format: 'table'
         },
         {
             refId: 'memory_requests',
             expr: `
                 sum(
-                    kube_pod_container_resource_requests{
-                        resource="memory",
-                        node=~"${nodeNames}",
-                        container!="",
+                    ${Metrics.kubePodContainerResourceRequests.name}{
+                        ${Metrics.kubePodContainerResourceRequests.labels.resource}="memory",
+                        ${Metrics.kubePodContainerResourceRequests.labels.node}=~"${nodeNames}",
+                        ${Metrics.kubePodContainerResourceRequests.labels.container}!="",
                         cluster="${cluster}"
                     }
-                ) by (node)`,
+                ) by (${Metrics.kubePodContainerResourceRequests.labels.node})`,
             instant: true,
             format: 'table'
         },
         {
             refId: 'cores',
             expr: `
-                count(
-                    count(
-                        node_cpu_seconds_total{
-                            instance=~"${nodes}",
-                            cluster="${cluster}"
-                        }
-                    ) by (cpu, instance)
-                ) by (instance)`,
+                max(
+                    ${Metrics.machineCpuCores.name}{
+                        ${Metrics.machineCpuCores.labels.node}=~"${nodeNames}",
+                        cluster="${cluster}"
+                    }
+                ) by (${Metrics.machineCpuCores.labels.node})`,    
             instant: true,
             format: 'table'
        },
        {
             refId: 'cpu_requests',
             expr: `
                 sum(
-                    kube_pod_container_resource_requests{
-                        resource="cpu",
-                        node=~"${nodeNames}",
-                        container!="",
+                    ${Metrics.kubePodContainerResourceRequests.name}{
+                        ${Metrics.kubePodContainerResourceRequests.labels.resource}="cpu",
+                        ${Metrics.kubePodContainerResourceRequests.labels.node}=~"${nodeNames}",
+                        ${Metrics.kubePodContainerResourceRequests.labels.container}!="",
                         cluster="${cluster}"
                     }
-                ) by (node)`,
+                ) by (${Metrics.kubePodContainerResourceRequests.labels.node})`,
             instant: true,
             format: 'table'
         },
         {
             refId: 'cpu_usage',
             expr: `
                 (
-                    sum by(instance) (
+                    sum by(${Metrics.nodeCpuSecondsTotal.labels.instance}) (
                         irate(
-                            node_cpu_seconds_total{
-                                instance=~"${nodes}",
-                                cluster="${cluster}",
-                                mode!="idle"
+                            ${Metrics.nodeCpuSecondsTotal.name}{
+                                ${Metrics.nodeCpuSecondsTotal.labels.instance}=~"${nodes}",
+                                ${Metrics.nodeCpuSecondsTotal.labels.mode}!="idle",
+                                cluster="${cluster}"
                             }[$__rate_interval]
                         )
                     )
                     /
-                    on (instance) group_left sum by (instance) (
+                    on (${Metrics.nodeCpuSecondsTotal.labels.instance}) group_left sum by (${Metrics.nodeCpuSecondsTotal.labels.instance}) (
                         (
                             irate(
-                                node_cpu_seconds_total{
-                                    instance=~"${nodes}",
+                                ${Metrics.nodeCpuSecondsTotal.name}{
+                                    ${Metrics.nodeCpuSecondsTotal.labels.instance}=~"${nodes}",
                                     cluster="${cluster}",
                                 }[$__rate_interval]
                             )
@@ -104,11 +109,11 @@ export function createRowQueries(nodes: string, nodeNames: string, sceneVariable
             refId: 'pod_count',
             expr: `
                 count(
-                    kube_pod_info{
-                        cluster="${cluster}",
-                        node=~"${nodeNames}"
+                    ${Metrics.kubePodInfo.name}{
+                        ${Metrics.kubePodInfo.labels.node}=~"${nodeNames}",
+                        cluster="${cluster}"
                     }
-                ) by (node)`,
+                ) by (${Metrics.kubePodInfo.labels.node})`,
             instant: true,
             format: 'table'
         }