chore: extract prometheus from core

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

packages/core/package.json

@@ -228,6 +228,7 @@
     "@k8slens/messaging-for-renderer": "^1.0.0-alpha.1",
     "@k8slens/metrics": "^6.5.0-alpha.7",
     "@k8slens/node-fetch": "^6.5.0-alpha.3",
+    "@k8slens/prometheus": "^1.0.0",
     "@k8slens/react-application": "^1.0.0-alpha.5",
     "@k8slens/random": "^1.0.0",
     "@k8slens/resizing-anchor": "^1.0.0-alpha.5",

packages/core/src/main/__test__/prometheus-handler.test.ts

@@ -7,8 +7,8 @@ import { getDiForUnitTesting } from "../getDiForUnitTesting";
 import { Cluster } from "../../common/cluster/cluster";
 import type { DiContainer } from "@ogre-tools/injectable";
 import { getInjectable } from "@ogre-tools/injectable";
-import type { PrometheusProvider } from "../prometheus/provider";
-import { prometheusProviderInjectionToken } from "../prometheus/provider";
+import type { PrometheusProvider } from "@k8slens/prometheus";
+import { prometheusProviderInjectionToken } from "@k8slens/prometheus";
 import { runInAction } from "mobx";
 import prometheusHandlerInjectable from "../cluster/prometheus-handler/prometheus-handler.injectable";
 import directoryForTempInjectable from "../../common/app-paths/directory-for-temp/directory-for-temp.injectable";

packages/core/src/main/cluster/prometheus-handler/prometheus-handler.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import type { PrometheusProvider, PrometheusService } from "../../prometheus/provider";
+import type { PrometheusProvider, PrometheusService } from "@k8slens/prometheus";
 import type { ClusterPrometheusPreferences } from "../../../common/cluster-types";
 import type { Cluster } from "../../../common/cluster/cluster";
 import { CoreV1Api } from "@kubernetes/client-node";

packages/core/src/main/prometheus/get-by-kind.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { matches } from "lodash/fp";
-import type { PrometheusProvider } from "./provider";
+import type { PrometheusProvider } from "@k8slens/prometheus";
 import prometheusProvidersInjectable from "./providers.injectable";
 
 export type GetPrometheusProviderByKind = (kind: string) => PrometheusProvider;

packages/core/src/main/prometheus/helm-14-provider.injectable.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getLensLikeQueryFor } from "./lens-provider.injectable";
-import { createPrometheusProvider, findFirstNamespacedService, prometheusProviderInjectionToken } from "./provider";
-import { getInjectable } from "@ogre-tools/injectable";
-
-const helm14PrometheusProviderInjectable = getInjectable({
-  id: "helm14-prometheus-provider",
-  instantiate: () => createPrometheusProvider({
-    kind: "helm14",
-    name: "Helm 14.x",
-    isConfigurable: true,
-    getQuery: getLensLikeQueryFor({ rateAccuracy: "5m" }),
-    getService: (client) => findFirstNamespacedService(client, "app=prometheus,component=server,heritage=Helm"),
-  }),
-  injectionToken: prometheusProviderInjectionToken,
-});
-
-export default helm14PrometheusProviderInjectable;
-

packages/core/src/main/prometheus/helm-provider.injectable.ts

@@ -1,146 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { PrometheusProvider } from "./provider";
-import { createPrometheusProvider, bytesSent, findFirstNamespacedService, prometheusProviderInjectionToken } from "./provider";
-import { getInjectable } from "@ogre-tools/injectable";
-
-export const getHelmLikeQueryFor = ({ rateAccuracy }: { rateAccuracy: string }): PrometheusProvider["getQuery"] => (
-  (opts, queryName) => {
-    switch(opts.category) {
-      case "cluster":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum(node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) by (component)`.replace(/_bytes/g, `_bytes{node=~"${opts.nodes}"}`);
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!="",instance=~"${opts.nodes}"}) by (component)`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{node=~"${opts.nodes}", mode=~"user|system"}[${rateAccuracy}]))`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "podUsage":
-            return `sum({__name__=~"kubelet_running_pod_count|kubelet_running_pods", instance=~"${opts.nodes}"})`;
-          case "podCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"}) by (component)`;
-          case "podAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="pods"}) by (component)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{node=~"${opts.nodes}", mountpoint="/"}) by (node)`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{node=~"${opts.nodes}", mountpoint="/"} - node_filesystem_avail_bytes{node=~"${opts.nodes}", mountpoint="/"}) by (node)`;
-        }
-        break;
-      case "nodes":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum(node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) by (node)`;
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!=""}) by (instance)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{resource="memory"}) by (node)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="memory"}) by (node)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${rateAccuracy}])) by(node)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"}) by (node)`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_avail_bytes{mountpoint="/"}) by (node)`;
-        }
-        break;
-      case "pods":
-        switch (queryName) {
-          case "cpuUsage":
-            return `sum(rate(container_cpu_usage_seconds_total{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsUsage":
-            return `sum(container_fs_usage_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsWrites":
-            return `sum(rate(container_fs_writes_bytes_total{container!="", pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "fsReads":
-            return `sum(rate(container_fs_reads_bytes_total{container!="", pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkReceive":
-            return `sum(rate(container_network_receive_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkTransmit":
-            return `sum(rate(container_network_transmit_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-        }
-        break;
-      case "pvc":
-        switch (queryName) {
-          case "diskUsage":
-            return `sum(kubelet_volume_stats_used_bytes{persistentvolumeclaim="${opts.pvc}",namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-          case "diskCapacity":
-            return `sum(kubelet_volume_stats_capacity_bytes{persistentvolumeclaim="${opts.pvc}",namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-        }
-        break;
-      case "ingress":
-        switch (queryName) {
-          case "bytesSentSuccess":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^2\\\\d*",
-            });
-          case "bytesSentFailure":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^5\\\\d*",
-            });
-          case "requestDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_request_duration_seconds_sum{ingress="${opts.ingress}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-          case "responseDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_response_duration_seconds_sum{ingress="${opts.ingress}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-        }
-        break;
-    }
-
-    throw new Error(`Unknown queryName="${queryName}" for category="${opts.category}"`);
-  }
-);
-
-const helmPrometheusProviderInjectable = getInjectable({
-  id: "helm-prometheus-provider",
-  instantiate: () => createPrometheusProvider({
-    kind: "helm",
-    name: "Helm",
-    isConfigurable: true,
-    getQuery: getHelmLikeQueryFor({ rateAccuracy: "5m" }),
-    getService: (client) => findFirstNamespacedService(client, "app=prometheus,component=server,heritage=Helm"),
-  }),
-  injectionToken: prometheusProviderInjectionToken,
-});
-
-export default helmPrometheusProviderInjectable;
-

packages/core/src/main/prometheus/lens-provider.injectable.ts

@@ -1,146 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { bytesSent, prometheusProviderInjectionToken, findNamespacedService, createPrometheusProvider } from "./provider";
-import type {  PrometheusProvider } from "./provider";
-import { getInjectable } from "@ogre-tools/injectable";
-
-export const getLensLikeQueryFor = ({ rateAccuracy }: { rateAccuracy: string }): PrometheusProvider["getQuery"] => (
-  (opts, queryName) => {
-    switch(opts.category) {
-      case "cluster":
-        switch (queryName) {
-          case "memoryUsage":
-            return `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=~"${opts.nodes}"}`);
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!="",instance=~"${opts.nodes}"}) by (component)`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{kubernetes_node=~"${opts.nodes}", mode=~"user|system"}[${rateAccuracy}]))`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "podUsage":
-            return `sum({__name__=~"kubelet_running_pod_count|kubelet_running_pods", instance=~"${opts.nodes}"})`;
-          case "podCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"}) by (component)`;
-          case "podAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="pods"}) by (component)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{kubernetes_node=~"${opts.nodes}", mountpoint="/"}) by (kubernetes_node)`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{kubernetes_node=~"${opts.nodes}", mountpoint="/"} - node_filesystem_avail_bytes{kubernetes_node=~"${opts.nodes}", mountpoint="/"}) by (kubernetes_node)`;
-        }
-        break;
-      case "nodes":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum (node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) by (kubernetes_node)`;
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!=""}) by (instance)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{resource="memory"}) by (node)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="memory"}) by (node)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${rateAccuracy}])) by(kubernetes_node)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"}) by (kubernetes_node)`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_avail_bytes{mountpoint="/"}) by (kubernetes_node)`;
-        }
-        break;
-      case "pods":
-        switch (queryName) {
-          case "cpuUsage":
-            return `sum(rate(container_cpu_usage_seconds_total{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsUsage":
-            return `sum(container_fs_usage_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsWrites":
-            return `sum(rate(container_fs_writes_bytes_total{container!="", pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "fsReads":
-            return `sum(rate(container_fs_reads_bytes_total{container!="", pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkReceive":
-            return `sum(rate(container_network_receive_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkTransmit":
-            return `sum(rate(container_network_transmit_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-        }
-        break;
-      case "pvc":
-        switch (queryName) {
-          case "diskUsage":
-            return `sum(kubelet_volume_stats_used_bytes{persistentvolumeclaim="${opts.pvc}",namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-          case "diskCapacity":
-            return `sum(kubelet_volume_stats_capacity_bytes{persistentvolumeclaim="${opts.pvc}",namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-        }
-        break;
-      case "ingress":
-        switch (queryName) {
-          case "bytesSentSuccess":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^2\\\\d*",
-            });
-          case "bytesSentFailure":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^5\\\\d*",
-            });
-          case "requestDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_request_duration_seconds_sum{ingress="${opts.ingress}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-          case "responseDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_response_duration_seconds_sum{ingress="${opts.ingress}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-        }
-        break;
-    }
-
-    throw new Error(`Unknown queryName="${queryName}" for category="${opts.category}"`);
-  }
-);
-
-const lensPrometheusProviderInjectable = getInjectable({
-  id: "lens-prometheus-provider",
-  instantiate: () => createPrometheusProvider({
-    kind: "lens",
-    name: "Lens",
-    isConfigurable: false,
-    getQuery: getLensLikeQueryFor({ rateAccuracy: "1m" }),
-    getService: (client) => findNamespacedService(client, "prometheus", "lens-metrics"),
-  }),
-  injectionToken: prometheusProviderInjectionToken,
-});
-
-export default lensPrometheusProviderInjectable;
-

packages/core/src/main/prometheus/operator-provider.injectable.ts.ts

@@ -1,146 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { PrometheusProvider } from "./provider";
-import { bytesSent, createPrometheusProvider, findFirstNamespacedService, prometheusProviderInjectionToken  } from "./provider";
-import { getInjectable } from "@ogre-tools/injectable";
-
-export const getOperatorLikeQueryFor = ({ rateAccuracy }: { rateAccuracy: string }): PrometheusProvider["getQuery"] => (
-  (opts, queryName) => {
-    switch(opts.category) {
-      case "cluster":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum(node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes))`.replace(/_bytes/g, `_bytes * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"}`);
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="", instance=~"${opts.nodes}"}) by (component)`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"})`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"})`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"})`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="memory"})`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${rateAccuracy}])* on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"})`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"})`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"})`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"})`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="cpu"})`;
-          case "podUsage":
-            return `sum({__name__=~"kubelet_running_pod_count|kubelet_running_pods", node=~"${opts.nodes}"})`;
-          case "podCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"})`;
-          case "podAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="pods"})`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"})`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"} - node_filesystem_avail_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"})`;
-        }
-        break;
-      case "nodes":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum((node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) * on (pod, namespace) group_left(node) kube_pod_info) by (node)`;
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD", container!=""}) by (node)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{resource="memory"}) by (node)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="memory"}) by (node)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${rateAccuracy}]) * on (pod, namespace) group_left(node) kube_pod_info) by (node)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info) by (node)`;
-          case "fsUsage":
-            return `sum((node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_avail_bytes{mountpoint="/"}) * on (pod, namespace) group_left(node) kube_pod_info) by (node)`;
-        }
-        break;
-      case "pods":
-        switch (queryName) {
-          case "cpuUsage":
-            return `sum(rate(container_cpu_usage_seconds_total{pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}", resource="cpu", namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}", resource="cpu", namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryUsage":
-            return `sum(container_memory_working_set_bytes{pod=~"${opts.pods}", namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}", resource="memory", namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}", resource="memory", namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsUsage":
-            return `sum(container_fs_usage_bytes{pod=~"${opts.pods}", namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsWrites":
-            return `sum(rate(container_fs_writes_bytes_total{pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "fsReads":
-            return `sum(rate(container_fs_reads_bytes_total{pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkReceive":
-            return `sum(rate(container_network_receive_bytes_total{pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkTransmit":
-            return `sum(rate(container_network_transmit_bytes_total{pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-        }
-        break;
-      case "pvc":
-        switch (queryName) {
-          case "diskUsage":
-            return `sum(kubelet_volume_stats_used_bytes{persistentvolumeclaim="${opts.pvc}", namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-          case "diskCapacity":
-            return `sum(kubelet_volume_stats_capacity_bytes{persistentvolumeclaim="${opts.pvc}", namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-        }
-        break;
-      case "ingress":
-        switch (queryName) {
-          case "bytesSentSuccess":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^2\\\\d*",
-            });
-          case "bytesSentFailure":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^5\\\\d*",
-            });
-          case "requestDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_request_duration_seconds_sum{ingress="${opts.ingress}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-          case "responseDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_response_duration_seconds_sum{ingress="${opts.ingress}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-        }
-        break;
-    }
-
-    throw new Error(`Unknown queryName="${queryName}" for category="${opts.category}"`);
-  }
-);
-
-const operatorPrometheusProviderInjectable = getInjectable({
-  id: "operator-prometheus-provider",
-  instantiate: () => createPrometheusProvider({
-    kind: "operator",
-    name: "Prometheus Operator",
-    isConfigurable: true,
-    getService: (client) => findFirstNamespacedService(client, "operated-prometheus=true"),
-    getQuery: getOperatorLikeQueryFor({ rateAccuracy: "1m" }),
-  }),
-  injectionToken: prometheusProviderInjectionToken,
-});
-
-export default operatorPrometheusProviderInjectable;
-

packages/core/src/main/prometheus/provider.ts

@@ -1,103 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { CoreV1Api } from "@kubernetes/client-node";
-import { getInjectionToken } from "@ogre-tools/injectable";
-import { isRequestError } from "@k8slens/utilities";
-
-export interface PrometheusService extends PrometheusServiceInfo {
-  kind: string;
-}
-
-export interface PrometheusServiceInfo {
-  namespace: string;
-  service: string;
-  port: number;
-}
-
-export interface PrometheusProvider {
-  readonly kind: string;
-  readonly name: string;
-  readonly isConfigurable: boolean;
-
-  getQuery(opts: Record<string, string>, queryName: string): string;
-  getPrometheusService(client: CoreV1Api): Promise<PrometheusService>;
-}
-
-export interface CreatePrometheusProviderOpts {
-  readonly kind: string;
-  readonly name: string;
-  readonly isConfigurable: boolean;
-
-  getQuery(opts: Record<string, string>, queryName: string): string;
-  getService(client: CoreV1Api): Promise<PrometheusServiceInfo>;
-}
-
-export const createPrometheusProvider = ({ getService, ...opts }: CreatePrometheusProviderOpts): PrometheusProvider => ({
-  ...opts,
-  getPrometheusService: async (client) => {
-    try {
-      return {
-        kind: opts.kind,
-        ...await getService(client),
-      };
-    } catch (error) {
-      throw new Error(`Failed to find Prometheus provider for "${opts.name}"`, { cause: error });
-    }
-  },
-});
-
-export async function findFirstNamespacedService(client: CoreV1Api, ...selectors: string[]): Promise<PrometheusServiceInfo> {
-  try {
-    for (const selector of selectors) {
-      const { body: { items: [service] }} = await client.listServiceForAllNamespaces(undefined, undefined, undefined, selector);
-
-      if (service?.metadata?.namespace && service.metadata.name && service.spec?.ports) {
-        return {
-          namespace: service.metadata.namespace,
-          service: service.metadata.name,
-          port: service.spec.ports[0].port,
-        };
-      }
-    }
-  } catch (error) {
-    throw new Error(`Failed to list services in all namespaces: ${isRequestError(error) ? error.response?.body.message : error}`);
-  }
-
-  throw new Error(`No service found from any namespace`);
-}
-
-export async function findNamespacedService(client: CoreV1Api, name: string, namespace: string): Promise<PrometheusServiceInfo> {
-  try {
-    const { body: service } = await client.readNamespacedService(name, namespace);
-
-    if (!service.metadata?.namespace || !service.metadata.name || !service.spec?.ports) {
-      throw new Error(`Service found in namespace="${namespace}" did not have required information`);
-    }
-
-    return {
-      namespace: service.metadata.namespace,
-      service: service.metadata.name,
-      port: service.spec.ports[0].port,
-    };
-  } catch(error) {
-    throw new Error(`Failed to list services in namespace="${namespace}": ${isRequestError(error) ? error.response?.body.message : error}`);
-  }
-}
-
-export interface BytesSentArgs {
-  rateAccuracy: string;
-  ingress: string;
-  namespace: string;
-  statuses: string;
-}
-
-export function bytesSent({ rateAccuracy, ingress, namespace, statuses }: BytesSentArgs): string {
-  return `sum(rate(nginx_ingress_controller_bytes_sent_sum{ingress="${ingress}",namespace="${namespace}",status=~"${statuses}"}[${rateAccuracy}])) by (ingress, namespace)`;
-}
-
-export const prometheusProviderInjectionToken = getInjectionToken<PrometheusProvider>({
-  id: "prometheus-provider",
-});

packages/core/src/main/prometheus/providers.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { computedInjectManyInjectable } from "@ogre-tools/injectable-extension-for-mobx";
-import { prometheusProviderInjectionToken } from "./provider";
+import { prometheusProviderInjectionToken } from "@k8slens/prometheus";
 
 const prometheusProvidersInjectable = getInjectable({
   id: "prometheus-providers",

packages/core/src/main/prometheus/stacklight-provider.injectable.ts

@@ -1,146 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { PrometheusProvider } from "./provider";
-import { bytesSent, createPrometheusProvider, findFirstNamespacedService, prometheusProviderInjectionToken } from "./provider";
-import { getInjectable } from "@ogre-tools/injectable";
-
-export const getStacklightLikeQueryFor = ({ rateAccuracy }: { rateAccuracy: string }): PrometheusProvider["getQuery"] => (
-  (opts, queryName) => {
-    switch(opts.category) {
-      case "cluster":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum(node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) by (kubernetes_name)`.replace(/_bytes/g, `_bytes{node=~"${opts.nodes}"}`);
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!="",instance=~"${opts.nodes}"}) by (component)`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="memory"}) by (component)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{node=~"${opts.nodes}", mode=~"user|system"}[${rateAccuracy}]))`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="cpu"}) by (component)`;
-          case "podUsage":
-            return `sum({__name__=~"kubelet_running_pod_count|kubelet_running_pods", instance=~"${opts.nodes}"})`;
-          case "podCapacity":
-            return `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"}) by (component)`;
-          case "podAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{node=~"${opts.nodes}", resource="pods"}) by (component)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{node=~"${opts.nodes}", mountpoint="/"}) by (node)`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{node=~"${opts.nodes}", mountpoint="/"} - node_filesystem_avail_bytes{node=~"${opts.nodes}", mountpoint="/"}) by (node)`;
-        }
-        break;
-      case "nodes":
-        switch (queryName) {
-          case "memoryUsage":
-            return `sum (node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) by (node)`;
-          case "workloadMemoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!=""}) by (instance)`;
-          case "memoryCapacity":
-            return `sum(kube_node_status_capacity{resource="memory"}) by (node)`;
-          case "memoryAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="memory"}) by (node)`;
-          case "cpuUsage":
-            return `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${rateAccuracy}])) by(node)`;
-          case "cpuCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "cpuAllocatableCapacity":
-            return `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`;
-          case "fsSize":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"}) by (node)`;
-          case "fsUsage":
-            return `sum(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_avail_bytes{mountpoint="/"}) by (node)`;
-        }
-        break;
-      case "pods":
-        switch (queryName) {
-          case "cpuUsage":
-            return `sum(rate(container_cpu_usage_seconds_total{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "cpuRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "cpuLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryUsage":
-            return `sum(container_memory_working_set_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryRequests":
-            return `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "memoryLimits":
-            return `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsUsage":
-            return `sum(container_fs_usage_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`;
-          case "fsWrites":
-            return `sum(rate(container_fs_writes_bytes_total{container!="", pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "fsReads":
-            return `sum(rate(container_fs_reads_bytes_total{container!="", pod=~"${opts.pods}", namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkReceive":
-            return `sum(rate(container_network_receive_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-          case "networkTransmit":
-            return `sum(rate(container_network_transmit_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (${opts.selector})`;
-        }
-        break;
-      case "pvc":
-        switch (queryName) {
-          case "diskUsage":
-            return `sum(kubelet_volume_stats_used_bytes{persistentvolumeclaim="${opts.pvc}",namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-          case "diskCapacity":
-            return `sum(kubelet_volume_stats_capacity_bytes{persistentvolumeclaim="${opts.pvc}",namespace="${opts.namespace}"}) by (persistentvolumeclaim, namespace)`;
-        }
-        break;
-      case "ingress":
-        switch (queryName) {
-          case "bytesSentSuccess":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^2\\\\d*",
-            });
-          case "bytesSentFailure":
-            return bytesSent({
-              rateAccuracy,
-              ingress: opts.ingress,
-              namespace: opts.namespace,
-              statuses: "^5\\\\d*",
-            });
-          case "requestDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_request_duration_seconds_sum{ingress="${opts.ingress}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-          case "responseDurationSeconds":
-            return `sum(rate(nginx_ingress_controller_response_duration_seconds_sum{ingress="${opts.ingress}",namespace="${opts.namespace}"}[${rateAccuracy}])) by (ingress, namespace)`;
-        }
-        break;
-    }
-
-    throw new Error(`Unknown queryName="${queryName}" for category="${opts.category}"`);
-  }
-);
-
-const stacklightPrometheusProviderInjectable = getInjectable({
-  id: "stacklight-prometheus-provider",
-  instantiate: () => createPrometheusProvider({
-    kind: "stacklight",
-    name: "Stacklight",
-    isConfigurable: true,
-    getService: (client) => findFirstNamespacedService(client, "prometheus-server", "stacklight"),
-    getQuery: getStacklightLikeQueryFor({ rateAccuracy: "1m" }),
-  }),
-  injectionToken: prometheusProviderInjectionToken,
-});
-
-export default stacklightPrometheusProviderInjectable;
-