Allow to select Prometheus query style (#312)

Signed-off-by: Lauri Nevala <lauri.nevala@gmail.com>

dashboard/client/api/endpoints/cluster.api.ts

@@ -5,37 +5,21 @@ import { KubeApi } from "../kube-api";
 export class ClusterApi extends KubeApi<Cluster> {
   async getMetrics(nodeNames: string[], params?: IMetricsReqParams): Promise<IClusterMetrics> {
     const nodes = nodeNames.join("|");
-    const memoryUsage = `
-        sum(
-          node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)
-        ) by (kubernetes_name)
-      `.replace(/_bytes/g, `_bytes{kubernetes_node=~"${nodes}"}`);
-
-    const memoryRequests = `sum(kube_pod_container_resource_requests{node=~"${nodes}", resource="memory"}) by (component)`;
-    const memoryLimits = `sum(kube_pod_container_resource_limits{node=~"${nodes}", resource="memory"}) by (component)`;
-    const memoryCapacity = `sum(kube_node_status_capacity{node=~"${nodes}", resource="memory"}) by (component)`;
-    const cpuUsage = `sum(rate(node_cpu_seconds_total{kubernetes_node=~"${nodes}", mode=~"user|system"}[1m]))`;
-    const cpuRequests = `sum(kube_pod_container_resource_requests{node=~"${nodes}", resource="cpu"}) by (component)`;
-    const cpuLimits = `sum(kube_pod_container_resource_limits{node=~"${nodes}", resource="cpu"}) by (component)`;
-    const cpuCapacity = `sum(kube_node_status_capacity{node=~"${nodes}", resource="cpu"}) by (component)`;
-    const podUsage = `sum(kubelet_running_pod_count{instance=~"${nodes}"})`;
-    const podCapacity = `sum(kube_node_status_capacity{node=~"${nodes}", resource="pods"}) by (component)`;
-    const fsSize = `sum(node_filesystem_size_bytes{kubernetes_node=~"${nodes}", mountpoint="/"}) by (kubernetes_node)`;
-    const fsUsage = `sum(node_filesystem_size_bytes{kubernetes_node=~"${nodes}", mountpoint="/"} - node_filesystem_avail_bytes{kubernetes_node=~"${nodes}", mountpoint="/"}) by (kubernetes_node)`;
+    const opts = { category: "cluster", nodes: nodes }
 
     return metricsApi.getMetrics({
-      memoryUsage,
-      memoryRequests,
-      memoryLimits,
-      memoryCapacity,
-      cpuUsage,
-      cpuRequests,
-      cpuLimits,
-      cpuCapacity,
-      podUsage,
-      podCapacity,
-      fsSize,
-      fsUsage
+      memoryUsage: opts,
+      memoryRequests: opts,
+      memoryLimits: opts,
+      memoryCapacity: opts,
+      cpuUsage: opts,
+      cpuRequests: opts,
+      cpuLimits: opts,
+      cpuCapacity: opts,
+      podUsage: opts,
+      podCapacity: opts,
+      fsSize: opts,
+      fsUsage: opts
     }, params);
   }
 }

dashboard/client/api/endpoints/ingress.api.ts

@@ -5,17 +5,12 @@ import { KubeApi } from "../kube-api";
 
 export class IngressApi extends KubeApi<Ingress> {
   getMetrics(ingress: string, namespace: string): Promise<IIngressMetrics> {
-    const bytesSent = (statuses: string) =>
-      `sum(rate(nginx_ingress_controller_bytes_sent_sum{ingress="${ingress}", status=~"${statuses}"}[1m])) by (ingress)`;
-    const bytesSentSuccess = bytesSent("^2\\\\d*");  // Requests with status 2**
-    const bytesSentFailure = bytesSent("^5\\\\d*");  // Requests with status 5**
-    const requestDurationSeconds = `sum(rate(nginx_ingress_controller_request_duration_seconds_sum{ingress="${ingress}"}[1m])) by (ingress)`;
-    const responseDurationSeconds = `sum(rate(nginx_ingress_controller_response_duration_seconds_sum{ingress="${ingress}"}[1m])) by (ingress)`;
+    const opts = { category: "ingress", ingress }
     return metricsApi.getMetrics({
-      bytesSentSuccess,
-      bytesSentFailure,
-      requestDurationSeconds,
-      responseDurationSeconds
+      bytesSentSuccess: opts,
+      bytesSentFailure: opts,
+      requestDurationSeconds: opts,
+      responseDurationSeconds: opts
     }, {
       namespace,
     });

dashboard/client/api/endpoints/nodes.api.ts

@@ -5,24 +5,15 @@ import { KubeApi } from "../kube-api";
 
 export class NodesApi extends KubeApi<Node> {
   getMetrics(): Promise<INodeMetrics> {
-    const memoryUsage = `
-        sum (
-          node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)
-        ) by (kubernetes_node)
-      `;
-    const memoryCapacity = `sum(kube_node_status_capacity{resource="memory"}) by (node)`;
-    const cpuUsage = `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[1m])) by(kubernetes_node)`;
-    const cpuCapacity = `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-    const fsSize = `sum(node_filesystem_size_bytes{mountpoint="/"}) by (kubernetes_node)`;
-    const fsUsage = `sum(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_avail_bytes{mountpoint="/"}) by (kubernetes_node)`;
+    const opts = { category: "nodes"}
 
     return metricsApi.getMetrics({
-      memoryUsage,
-      memoryCapacity,
-      cpuUsage,
-      cpuCapacity,
-      fsSize,
-      fsUsage
+      memoryUsage: opts,
+      memoryCapacity: opts,
+      cpuUsage: opts,
+      cpuCapacity: opts,
+      fsSize: opts,
+      fsUsage: opts
     });
   }
 }

dashboard/client/api/endpoints/persistent-volume-claims.api.ts

@@ -6,12 +6,9 @@ import { KubeApi } from "../kube-api";
 
 export class PersistentVolumeClaimsApi extends KubeApi<PersistentVolumeClaim> {
   getMetrics(pvcName: string, namespace: string): Promise<IPvcMetrics> {
-    const diskUsage = `sum(kubelet_volume_stats_used_bytes{persistentvolumeclaim="${pvcName}"}) by (persistentvolumeclaim, namespace)`;
-    const diskCapacity = `sum(kubelet_volume_stats_capacity_bytes{persistentvolumeclaim="${pvcName}"}) by (persistentvolumeclaim, namespace)`;
-
     return metricsApi.getMetrics({
-      diskUsage,
-      diskCapacity
+      diskUsage: { category: 'pvc', pvc: pvcName },
+      diskCapacity: { category: 'pvc', pvc: pvcName }
     }, {
       namespace
     });

dashboard/client/api/endpoints/pods.api.ts

@@ -11,26 +11,18 @@ export class PodsApi extends KubeApi<Pod> {
 
   getMetrics(pods: Pod[], namespace: string, selector = "pod, namespace"): Promise<IPodMetrics> {
     const podSelector = pods.map(pod => pod.getName()).join("|");
-    const cpuUsage = `sum(rate(container_cpu_usage_seconds_total{container_name!="POD",container_name!="",pod_name=~"${podSelector}",namespace="${namespace}"}[1m])) by (${selector})`;
-    const cpuRequests = `sum(kube_pod_container_resource_requests{pod=~"${podSelector}",resource="cpu",namespace="${namespace}"}) by (${selector})`;
-    const cpuLimits = `sum(kube_pod_container_resource_limits{pod=~"${podSelector}",resource="cpu",namespace="${namespace}"}) by (${selector})`;
-    const memoryUsage = `sum(container_memory_working_set_bytes{container_name!="POD",container_name!="",pod_name=~"${podSelector}",namespace="${namespace}"}) by (${selector})`;
-    const memoryRequests = `sum(kube_pod_container_resource_requests{pod=~"${podSelector}",resource="memory",namespace="${namespace}"}) by (${selector})`;
-    const memoryLimits = `sum(kube_pod_container_resource_limits{pod=~"${podSelector}",resource="memory",namespace="${namespace}"}) by (${selector})`;
-    const fsUsage = `sum(container_fs_usage_bytes{container_name!="POD",container_name!="",pod_name=~"${podSelector}",namespace="${namespace}"}) by (${selector})`;
-    const networkReceive = `sum(rate(container_network_receive_bytes_total{pod_name=~"${podSelector}",namespace="${namespace}"}[1m])) by (${selector})`;
-    const networkTransit = `sum(rate(container_network_transmit_bytes_total{pod_name=~"${podSelector}",namespace="${namespace}"}[1m])) by (${selector})`;
+    const opts = { category: "pods", pods: podSelector, namespace, selector }
 
     return metricsApi.getMetrics({
-      cpuUsage,
-      cpuRequests,
-      cpuLimits,
-      memoryUsage,
-      memoryRequests,
-      memoryLimits,
-      fsUsage,
-      networkReceive,
-      networkTransit,
+      cpuUsage: opts,
+      cpuRequests: opts,
+      cpuLimits: opts,
+      memoryUsage: opts,
+      memoryRequests: opts,
+      memoryLimits: opts,
+      fsUsage: opts,
+      networkReceive: opts,
+      networkTransit: opts,
     }, {
       namespace,
     });