chore: extract prometheus from core

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

packages/technical-features/prometheus/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+    extends: "@k8slens/eslint-config/eslint",
+    parserOptions: {
+      project: "./tsconfig.json",
+    },
+  };

packages/technical-features/prometheus/.prettierrc

@@ -0,0 +1 @@
+"@k8slens/eslint-config/prettier"

packages/technical-features/prometheus/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

packages/technical-features/prometheus/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+export { prometheusFeature } from "./src/feature";
+export * from "./src/provider";

packages/technical-features/prometheus/jest.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/jest").monorepoPackageConfig(__dirname).configForNode;

packages/technical-features/prometheus/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@k8slens/prometheus",
+  "private": false,
+  "version": "1.0.0",
+  "description": "Prometheus support for Lens",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lensapp/lens.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": {
+    "name": "OpenLens Authors",
+    "email": "info@k8slens.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lensapp/lens",
+  "scripts": {
+    "build": "lens-webpack-build",
+    "clean": "rimraf dist/",
+    "dev": "webpack --mode=development --watch",
+    "test": "jest --coverage --runInBand",
+    "lint": "lens-lint",
+    "lint:fix": "lens-lint --fix"
+  },
+  "peerDependencies": {
+    "@k8slens/application": "^6.5.0-alpha.2",
+    "@k8slens/feature-core": "^6.5.0-alpha.0",
+    "@k8slens/utilities": "^1.0.0-alpha.7",
+    "@kubernetes/client-node": "^0.18.1",
+    "@ogre-tools/fp": "^17.2.0",
+    "@ogre-tools/injectable": "^17.2.0",
+    "@ogre-tools/injectable-extension-for-auto-registration": "^17.2.0",
+    "@ogre-tools/injectable-extension-for-mobx": "^17.2.0"
+  },
+  "devDependencies": {
+    "@k8slens/eslint-config": "^6.5.0-alpha.3",
+    "@k8slens/jest": "^6.5.0-alpha.5",
+    "@k8slens/typescript": "^6.5.0-alpha.3",
+    "@k8slens/webpack": "^6.5.0-alpha.9"
+  }
+}

packages/technical-features/prometheus/src/feature.ts

@@ -0,0 +1,17 @@
+import { getFeature } from "@k8slens/feature-core";
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+import { applicationFeature } from "@k8slens/application";
+
+export const prometheusFeature = getFeature({
+  id: "prometheus",
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+      getRequireContexts: () => [require.context("./", true, /\.injectable\.(ts|tsx)$/)],
+    });
+  },
+
+  dependencies: [applicationFeature],
+});

packages/technical-features/prometheus/src/helm-14-provider.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * 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/technical-features/prometheus/src/helm-provider.injectable.ts

@@ -0,0 +1,154 @@
+/**
+ * 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/technical-features/prometheus/src/lens-provider.injectable.ts

@@ -0,0 +1,154 @@
+/**
+ * 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/technical-features/prometheus/src/operator-provider.injectable.ts.ts

@@ -0,0 +1,154 @@
+/**
+ * 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/technical-features/prometheus/src/provider.ts

@@ -0,0 +1,123 @@
+/**
+ * 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/technical-features/prometheus/src/stacklight-provider.injectable.ts

@@ -0,0 +1,154 @@
+/**
+ * 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;

packages/technical-features/prometheus/tsconfig.json

@@ -0,0 +1,4 @@
+{
+    "extends": "@k8slens/typescript/config/base.json",
+    "include": ["**/*.ts"]
+  }

packages/technical-features/prometheus/webpack.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/webpack").configForNode;