@kwirthmagnify/kwirth-plugin-metrics 0.0.0-stage → 0.1.0

package/back.js

@@ -0,0 +1,756 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// kwirth-back-globals:@kwirthmagnify/kwirth-common
+var require_kwirth_common = __commonJS({
+  "kwirth-back-globals:@kwirthmagnify/kwirth-common"(exports2, module2) {
+    module2.exports = global.__kwirth_back__.kwirthCommon;
+  }
+});
+
+// src/back/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MetricsChannel: () => MetricsChannel
+});
+module.exports = __toCommonJS(index_exports);
+var import_kwirth_common = __toESM(require_kwirth_common(), 1);
+var CLUSTER_ASSET = "Cluster";
+var isClusterMetric = (metricName) => metricName.startsWith("kwirth_cluster_");
+var MetricsChannel = class {
+  constructor(clusterInfo, backChannelObject) {
+    this.channelId = "metrics";
+    this.requirements = {
+      storage: false,
+      providers: ["metrics"]
+    };
+    this.metricsCluster = [];
+    // list of intervals (and its associated metrics) that produce metrics streams
+    this.webSockets = [];
+    this.startChannel = async () => {
+      this.clusterInfo.addSubscriber("metrics", this, {});
+    };
+    // Called by the core before replacing this instance (hot reload) or uninstalling the plugin: drop the
+    // provider subscription and every running interval, so the old instance does not keep working.
+    this.cleanup = () => {
+      try {
+        this.clusterInfo.removeSubscriber("metrics", this);
+      } catch {
+      }
+      for (const socket of this.webSockets) {
+        for (const instance of socket.instances) {
+          if (instance.timeout) clearInterval(instance.timeout);
+        }
+      }
+      this.webSockets = [];
+      this.metricsCluster = [];
+    };
+    this.containsAsset = (webSocket, podNamespace, podName, containerName) => {
+      let socket = this.webSockets.find((s) => s.ws === webSocket);
+      if (socket) {
+        let instances = socket.instances;
+        if (instances) return instances.some((i) => i.assets.some((a) => a.podNamespace === podNamespace && a.podName === podName && a.containerName === containerName));
+      }
+      return false;
+    };
+    this.checkScopes = (instanceConfig, scope) => {
+      let resources = (0, import_kwirth_common.parseResources)((0, import_kwirth_common.accessKeyDeserialize)(instanceConfig.accessKey).resources);
+      let requiredLevel = this.getChannelScopeLevel(scope);
+      let canPerform = resources.some((r) => r.scopes.split(",").some((sc) => this.getChannelScopeLevel(sc) >= requiredLevel));
+      return canPerform;
+    };
+    this.addObject = async (webSocket, instanceConfig, podNamespace, podName, containerName) => {
+      try {
+        const podResponse = await this.clusterInfo.coreApi.readNamespacedPod({ name: podName, namespace: podNamespace });
+        const owner = podResponse.metadata?.ownerReferences?.find((owner2) => owner2.controller);
+        const podNode = podResponse.spec?.nodeName;
+        let podGroup = void 0;
+        if (owner) {
+          podGroup = owner.kind.toLocaleLowerCase() + "+" + owner.name;
+        } else {
+          this.backChannelObject.logInfo?.(`No owner found for ${podName}, assume pod/container without controller`);
+        }
+        switch (instanceConfig.data.mode) {
+          case "snapshot" /* SNAPSHOT */: {
+            if (!this.checkScopes(instanceConfig, import_kwirth_common.InstanceConfigScopeEnum.SNAPSHOT)) {
+              this.backChannelObject.logInfo?.("Insufficient scope for SNAPSHOT");
+              this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, "Insufficient scope for SNAPSHOT", instanceConfig);
+              return false;
+            }
+            if (podNode) {
+              this.backChannelObject.logInfo?.(`Send snapshot metrics for ${podNode}/${podNamespace}/${podGroup}/${podName}/${containerName}`);
+              let socket = this.webSockets.find((entry) => entry.ws === webSocket);
+              if (!socket) {
+                this.backChannelObject.logInfo?.("No socket found for startInstance snapshot");
+                return false;
+              }
+              let instances = socket.instances;
+              let instance = instances?.find((instance2) => instance2.instanceId === instanceConfig.instance);
+              if (instance) {
+                this.sendMetricsDataInstance(webSocket, instanceConfig.instance, false);
+                return true;
+              } else {
+                this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, `Instance ${instanceConfig.instance} not found`, instanceConfig);
+                return false;
+              }
+            }
+          }
+          case "stream" /* STREAM */: {
+            if (!this.checkScopes(instanceConfig, import_kwirth_common.InstanceConfigScopeEnum.STREAM)) {
+              this.backChannelObject.logInfo?.("Insufficient scope for STREAM");
+              this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, "Insufficient scope for STREAM", instanceConfig);
+              return false;
+            }
+            if (podNode) {
+              this.backChannelObject.logInfo?.(`Start pod metrics for ${podNode}/${podNamespace}/${podGroup}/${podName}/${containerName}`);
+              let socket = this.webSockets.find((entry) => entry.ws === webSocket);
+              let metricsConfig = instanceConfig.data;
+              let interval = (metricsConfig.interval || 15) * 1e3;
+              if (socket) {
+                let instances = socket.instances;
+                let instance = instances?.find((instance2) => instance2.instanceId === instanceConfig.instance);
+                if (!instance) {
+                  let timeout = setInterval((w, i, s) => this.sendMetricsDataInstance(w, i, s), interval, webSocket, instanceConfig.instance, false);
+                  instances?.push({
+                    instanceId: instanceConfig.instance,
+                    working: false,
+                    paused: false,
+                    timeout,
+                    interval,
+                    assets: [{ podNode, podNamespace, podGroup, podName, containerName }],
+                    instanceConfig
+                  });
+                  this.sendMetricsDataInstance(webSocket, instanceConfig.instance, true);
+                  return true;
+                }
+                if (instanceConfig.view === import_kwirth_common.EInstanceConfigView.CONTAINER) {
+                  instance.assets.push({ podNode, podNamespace, podGroup, podName, containerName });
+                  this.sendMetricsDataInstance(webSocket, instanceConfig.instance, true);
+                  return true;
+                } else {
+                  if (!instance.assets.find((asset) => asset.podName === podName && asset.containerName === containerName)) {
+                    instance.assets.push({ podNode, podNamespace, podGroup, podName, containerName });
+                    this.sendMetricsDataInstance(webSocket, instanceConfig.instance, true);
+                    return true;
+                  }
+                }
+                return false;
+              } else {
+                this.webSockets.push({ ws: webSocket, lastRefresh: Date.now(), instances: [] });
+                let timeout = setInterval((w, i, s) => this.sendMetricsDataInstance(w, i, s), interval, webSocket, instanceConfig.instance, false);
+                let instances = this.webSockets.find((entry) => entry.ws === webSocket)?.instances;
+                instances?.push({
+                  instanceId: instanceConfig.instance,
+                  working: false,
+                  paused: false,
+                  timeout,
+                  assets: [{ podNode, podNamespace, podGroup, podName, containerName }],
+                  instanceConfig,
+                  interval
+                });
+                this.sendMetricsDataInstance(webSocket, instanceConfig.instance, true);
+                return true;
+              }
+            } else {
+              this.backChannelObject.logInfo?.(`Cannot determine node for ${podNamespace}/${podName}, will not be added`);
+              return false;
+            }
+          }
+          default:
+            this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, `Invalid mode: ${instanceConfig.data.mode}`, instanceConfig);
+            return false;
+        }
+      } catch (err) {
+        this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, err?.stack ?? String(err), instanceConfig);
+        this.backChannelObject.logError?.("Generic error starting metrics instance");
+        this.backChannelObject.logError?.(err);
+        return false;
+      }
+    };
+    this.deleteObject = async (webSocket, instanceConfig, podNamespace, podName, containerName) => {
+      const socket = this.webSockets.find((s) => s.ws === webSocket);
+      const instance = socket?.instances.find((i) => i.instanceId === instanceConfig.instance);
+      if (instance) {
+        instance.assets = instance.assets.filter((a) => !(a.podNamespace === podNamespace && a.podName === podName && (containerName === "" || a.containerName === containerName)));
+      }
+      return true;
+    };
+    this.extractContainerMetrics = (podMetricsSet, containerMetricsSet, requestedMetricName, view, node, asset) => {
+      if (view === import_kwirth_common.EInstanceConfigView.CONTAINER) {
+        let metricName = asset.podNamespace + "/" + asset.podName + "/" + asset.containerName + "/" + requestedMetricName;
+        let value = containerMetricsSet.get(metricName)?.value;
+        if (value !== void 0) {
+          return { value, timestamp: node.timestamp };
+        } else {
+          return { value: 0, timestamp: node.timestamp };
+        }
+      } else {
+        const prefix = asset.podNamespace + "/" + asset.podName + "/";
+        const suffix = "/" + requestedMetricName;
+        let accum = 0;
+        let found = false;
+        for (const [k, v] of containerMetricsSet) {
+          if (k.startsWith(prefix) && k.endsWith(suffix)) {
+            accum += v.value;
+            found = true;
+          }
+        }
+        if (!found) {
+          const podValue = podMetricsSet.get(asset.podNamespace + "/" + asset.podName + "/" + requestedMetricName)?.value;
+          return { value: podValue ?? 0, timestamp: node.timestamp };
+        }
+        return { value: accum, timestamp: node.timestamp };
+      }
+    };
+    this.getAssetMetrics = (instanceConfig, assets, usePrevMetricSet) => {
+      if (this.metricsCluster.length < 2) {
+        return void 0;
+      }
+      let assetMetrics = { assetName: this.getAssetMetricName(instanceConfig, assets), values: [] };
+      let newAssets = [];
+      if (instanceConfig.view === import_kwirth_common.EInstanceConfigView.CONTAINER) {
+        newAssets = assets;
+      } else {
+        for (let a of assets) {
+          if (!newAssets.find((newAsset) => newAsset.podName === a.podName)) {
+            newAssets.push({
+              podNode: a.podNode,
+              podNamespace: a.podNamespace,
+              podGroup: a.podGroup,
+              podName: a.podName,
+              containerName: ""
+            });
+          }
+        }
+      }
+      for (let metricName of instanceConfig.data.metrics) {
+        if (isClusterMetric(metricName)) continue;
+        let sourceMetricName = metricName;
+        if (metricName === "kwirth_container_memory_percentage") sourceMetricName = "container_memory_working_set_bytes";
+        if (metricName === "kwirth_container_cpu_percentage") sourceMetricName = "container_cpu_usage_seconds_total";
+        if (metricName === "kwirth_container_transmit_percentage") sourceMetricName = "container_network_transmit_bytes_total";
+        if (metricName === "kwirth_container_receive_percentage") sourceMetricName = "container_network_receive_bytes_total";
+        if (metricName === "kwirth_container_transmit_mbps") sourceMetricName = "container_network_transmit_bytes_total";
+        if (metricName === "kwirth_container_receive_mbps") sourceMetricName = "container_network_receive_bytes_total";
+        if (metricName === "kwirth_container_write_mbps") sourceMetricName = "container_fs_writes_bytes_total";
+        if (metricName === "kwirth_container_read_mbps") sourceMetricName = "container_fs_reads_bytes_total";
+        if (metricName === "kwirth_container_random_counter" || metricName === "kwirth_container_random_gauge") sourceMetricName = "container_cpu_system_seconds_total";
+        let uniqueValues = [];
+        for (let asset of newAssets) {
+          let lastRead = this.metricsCluster[this.metricsCluster.length - 1];
+          let prevRead = this.metricsCluster[this.metricsCluster.length - 2];
+          let lastNode = lastRead.nodes.find((n) => n.name === asset.podNode);
+          let prevNode = prevRead.nodes.find((n) => n.name === asset.podNode);
+          if (!lastNode || !prevNode) {
+            this.backChannelObject.logError?.(`No node '${asset.podNode}' found for calculating metric value of ${asset.podNamespace}/${asset.podName}, asset skipped`);
+            continue;
+          }
+          let metric;
+          if (usePrevMetricSet)
+            metric = this.extractContainerMetrics(prevNode.podMetricValues, prevNode.containerMetricValues, sourceMetricName, instanceConfig.view, prevNode, asset);
+          else
+            metric = this.extractContainerMetrics(lastNode.podMetricValues, lastNode.containerMetricValues, sourceMetricName, instanceConfig.view, lastNode, asset);
+          uniqueValues.push(metric.value);
+        }
+        let metricValue = uniqueValues.reduce((acc, value) => acc + value, 0);
+        assetMetrics.values.push({ metricName, metricValue });
+      }
+      for (var i = 0; i < assetMetrics.values.length; i++) {
+        let m = assetMetrics.values[i];
+        switch (m.metricName) {
+          case "kwirth_container_memory_percentage":
+            let clusterMemory = Number.MAX_VALUE;
+            if (this.metricsCluster.length > 0) {
+              clusterMemory = this.metricsCluster[this.metricsCluster.length - 1].cluster.memory;
+            }
+            m.metricValue = Math.round(m.metricValue / clusterMemory * 100 * 100) / 100;
+            break;
+          case "kwirth_container_cpu_percentage":
+            if (!usePrevMetricSet) {
+              let prevValues2 = this.getAssetMetrics(instanceConfig, newAssets, true);
+              let prev = prevValues2?.values.find((prevMetric) => prevMetric.metricName === m.metricName);
+              if (prev) {
+                m.metricValue -= prev.metricValue;
+                if (m.metricValue < 0) {
+                  m.metricValue = prev.metricValue;
+                } else {
+                  let totalSecs = 1;
+                  if (this.metricsCluster.length > 0) {
+                    totalSecs = this.metricsCluster[this.metricsCluster.length - 1].metricsInterval * this.metricsCluster[this.metricsCluster.length - 1].cluster.vcpus;
+                    m.metricValue = Math.round(m.metricValue / totalSecs * 100 * 100) / 100;
+                  } else {
+                    m.metricValue = prev.metricValue;
+                  }
+                }
+              } else {
+                this.backChannelObject.logWarning?.(`No previous value [CPU] found for ${m.metricName}`);
+              }
+            }
+            break;
+          case "kwirth_container_random_counter":
+            m.metricValue = Date.now() % (Math.random() * 32 * 1e6);
+            break;
+          case "kwirth_container_random_gauge":
+            m.metricValue = Math.round(Math.random() * 100) / 100;
+            break;
+          case "kwirth_container_transmit_percentage":
+          case "kwirth_container_receive_percentage":
+            let totalBytes = 0;
+            for (let node of this.metricsCluster[this.metricsCluster.length - 1].nodes) {
+              let sourceMetricName = m.metricName === "kwirth_container_transmit_percentage" ? "container_network_transmit_bytes_total" : "container_network_receive_bytes_total";
+              let nodeMetrics = Array.from(node.podMetricValues.keys()).filter((k) => k.endsWith("/" + sourceMetricName));
+              nodeMetrics.map((m2) => {
+                totalBytes += node.podMetricValues.get(m2)?.value ?? 0;
+              });
+            }
+            m.metricValue = Math.round(m.metricValue / totalBytes * 100 * 100) / 100;
+            break;
+          case "kwirth_container_write_mbps":
+          case "kwirth_container_read_mbps":
+          case "kwirth_container_transmit_mbps":
+          case "kwirth_container_receive_mbps":
+            if (!usePrevMetricSet) {
+              var prevValues = this.getAssetMetrics(instanceConfig, newAssets, true);
+              let prev = prevValues?.values.find((prevMetric) => prevMetric.metricName === m.metricName);
+              if (prev) {
+                m.metricValue -= prev.metricValue;
+                m.metricValue *= 8;
+                m.metricValue /= 1024 * 1024;
+                let totalSecs = this.metricsCluster[0].metricsInterval;
+                m.metricValue = Math.round(m.metricValue / totalSecs * 100) / 100;
+              } else {
+                this.backChannelObject.logInfo?.(`No previous value found for ${m.metricName}`);
+              }
+            }
+            break;
+        }
+      }
+      return assetMetrics;
+    };
+    /*
+        The provider's cluster metrics (kwirth_cluster_*) are one value for the whole cluster. Repeating
+        them in every asset drew N identical series named after namespaces or pods they have nothing to do
+        with, so they go out ONCE, as a series of their own named CLUSTER_ASSET, whatever the view,
+        aggregation or merge. They need a single reading: they are not rates.
+    */
+    this.getClusterMetrics = (instanceConfig) => {
+      const clusterMetrics = instanceConfig.data.metrics.filter(isClusterMetric);
+      if (clusterMetrics.length === 0 || this.metricsCluster.length === 0) return void 0;
+      const lastRead = this.metricsCluster[this.metricsCluster.length - 1];
+      return {
+        assetName: CLUSTER_ASSET,
+        values: clusterMetrics.map((metricName) => ({ metricName, metricValue: lastRead.clusterMetricValues?.get(metricName)?.value ?? 0 }))
+      };
+    };
+    this.getAssetMetricName = (instanceConfig, assets) => {
+      switch (instanceConfig.view) {
+        case import_kwirth_common.EInstanceConfigView.NAMESPACE:
+          return [...new Set(assets.map((a) => a.podNamespace))].join(",");
+        case import_kwirth_common.EInstanceConfigView.GROUP:
+          let requestedGroups = instanceConfig.group.split(",");
+          return [...new Set(assets.map((a) => {
+            if (!a.podGroup) return void 0;
+            if (requestedGroups.includes(a.podGroup)) {
+              return a.podGroup;
+            } else {
+              let deploymentName = a.podGroup.substring(0, a.podGroup.lastIndexOf("-"));
+              let x = deploymentName.replace(/replicaset\+/g, "deployment+");
+              if (requestedGroups.includes(x)) {
+                return x;
+              } else {
+                return void 0;
+              }
+            }
+          }))].join(",");
+        case import_kwirth_common.EInstanceConfigView.POD:
+          return [...new Set(assets.map((a) => a.podName))].join(",");
+        case import_kwirth_common.EInstanceConfigView.CONTAINER:
+          return [...new Set(assets.map((a) => a.podName + "[" + a.containerName + "]"))].join(",");
+        default:
+          return "unnamedView";
+      }
+    };
+    this.fillData = (instanceConfig, instance, responseMessage) => {
+      switch (instanceConfig.view) {
+        case import_kwirth_common.EInstanceConfigView.NAMESPACE:
+          if (instanceConfig.data.aggregate) {
+            let assetMetrics2 = this.getAssetMetrics(instanceConfig, instance.assets, false);
+            if (assetMetrics2) responseMessage.assets.push(assetMetrics2);
+          } else {
+            const namespaces = [...new Set(instance.assets.map((item) => item.podNamespace))];
+            for (let namespace of namespaces) {
+              let assets2 = instance.assets.filter((a) => a.podNamespace === namespace);
+              let assetMetrics2 = this.getAssetMetrics(instanceConfig, assets2, false);
+              if (assetMetrics2) responseMessage.assets.push(assetMetrics2);
+            }
+          }
+          break;
+        case import_kwirth_common.EInstanceConfigView.GROUP:
+          if (instanceConfig.data.aggregate) {
+            var assetMetrics = this.getAssetMetrics(instanceConfig, instance.assets, false);
+            if (assetMetrics) responseMessage.assets.push(assetMetrics);
+          } else {
+            const groupNames = [...new Set(instance.assets.map((item) => item.podGroup))];
+            for (let groupName of groupNames) {
+              let assets2 = instance.assets.filter((a) => a.podGroup === groupName);
+              let assetMetrics2 = this.getAssetMetrics(instanceConfig, assets2, false);
+              if (assetMetrics2) responseMessage.assets.push(assetMetrics2);
+            }
+          }
+          break;
+        case import_kwirth_common.EInstanceConfigView.POD:
+          if (instanceConfig.data.aggregate) {
+            var assetMetrics = this.getAssetMetrics(instanceConfig, instance.assets, false);
+            if (assetMetrics) responseMessage.assets.push(assetMetrics);
+          } else {
+            const uniquePodNames = [...new Set(instance.assets.map((asset2) => asset2.podName))];
+            for (var podName of uniquePodNames) {
+              var assets = instance.assets.filter((a) => a.podName === podName);
+              var assetMetrics = this.getAssetMetrics(instanceConfig, assets, false);
+              if (assetMetrics) responseMessage.assets.push(assetMetrics);
+            }
+          }
+          break;
+        case import_kwirth_common.EInstanceConfigView.CONTAINER:
+          if (instanceConfig.data.aggregate) {
+            var assetMetrics = this.getAssetMetrics(instanceConfig, instance.assets, false);
+            if (assetMetrics) responseMessage.assets.push(assetMetrics);
+          } else {
+            for (var asset of instance.assets) {
+              var assetMetrics = this.getAssetMetrics(instanceConfig, [asset], false);
+              if (assetMetrics) responseMessage.assets.push(assetMetrics);
+            }
+          }
+          break;
+        default:
+          this.backChannelObject.logWarning?.(`Invalid view:` + instanceConfig.view);
+      }
+      responseMessage.assets = responseMessage.assets.filter((asset2) => asset2.values.length > 0);
+      const clusterMetrics = this.getClusterMetrics(instanceConfig);
+      if (clusterMetrics) responseMessage.assets.push(clusterMetrics);
+    };
+    this.sendMetricsDataInstance = (webSocket, instanceId, initial) => {
+      let socket = this.webSockets.find((entry) => entry.ws === webSocket);
+      if (!socket) {
+        this.backChannelObject.logInfo?.("No socket found for sendMetricsData");
+        return;
+      }
+      let instances = socket.instances;
+      if (!instances) {
+        this.backChannelObject.logInfo?.("No instances found for sendMetricsData");
+        return;
+      }
+      var instance = instances.find((i) => i.instanceId === instanceId);
+      if (!instance) {
+        this.backChannelObject.logInfo?.(`No instance found for sendMetricsData instance ${instanceId}`);
+        return;
+      }
+      if (instance.working) {
+        this.backChannelObject.logInfo?.(`Previous instance of ${instanceId} is still running`);
+        return;
+      }
+      if (instance.paused) {
+        this.backChannelObject.logInfo?.(`Instance ${instanceId} is paused, no SMD performed`);
+        return;
+      }
+      instance.working = true;
+      let instanceConfig = instance.instanceConfig;
+      try {
+        let metricsMessageResponse = {
+          msgtype: "metricsmessageresponse",
+          action: import_kwirth_common.EInstanceMessageAction.NONE,
+          flow: import_kwirth_common.EInstanceMessageFlow.UNSOLICITED,
+          channel: import_kwirth_common.EInstanceMessageChannel.METRICS,
+          type: import_kwirth_common.EInstanceMessageType.DATA,
+          instance: instanceConfig.instance,
+          assets: [],
+          namespace: instanceConfig.namespace,
+          group: "",
+          pod: instanceConfig.pod,
+          timestamp: initial ? 0 : Date.now(),
+          container: ""
+        };
+        this.fillData(instanceConfig, instance, metricsMessageResponse);
+        if (metricsMessageResponse.assets.length > 0) {
+          try {
+            webSocket.send(JSON.stringify(metricsMessageResponse));
+          } catch (err) {
+            this.backChannelObject.logInfo?.("Socket error, we should forget interval");
+          }
+        }
+        instance.working = false;
+      } catch (err) {
+        this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.WARNING, `Cannot read metrics for instance ${instanceId}`, instanceConfig);
+        this.backChannelObject.logError?.("Error reading metrics");
+        this.backChannelObject.logError?.(err);
+      }
+    };
+    this.sendInstanceConfigMessage = (ws, action, flow, channel, instanceConfig, text) => {
+      var resp = {
+        action,
+        flow,
+        channel,
+        instance: instanceConfig.instance,
+        type: import_kwirth_common.EInstanceMessageType.SIGNAL,
+        text
+      };
+      ws.send(JSON.stringify(resp));
+    };
+    this.clusterInfo = clusterInfo;
+    this.backChannelObject = backChannelObject;
+  }
+  getChannelData() {
+    return {
+      id: "metrics",
+      routable: false,
+      pauseable: true,
+      modifiable: true,
+      reconnectable: true,
+      metrics: true,
+      sources: [import_kwirth_common.EClusterType.KUBERNETES],
+      endpoints: [],
+      websocket: false,
+      cluster: false,
+      resourced: true
+    };
+  }
+  getChannelScopeLevel(scope) {
+    return ["", "snapshot", "stream", "cluster", "admin"].indexOf(scope);
+  }
+  async processProviderEvent(providerId, event) {
+    switch (providerId) {
+      case "metrics":
+        this.metricsCluster.push(event);
+        if (this.metricsCluster.length > 100) this.metricsCluster.shift();
+        break;
+      default:
+        this.backChannelObject.logError?.(`Ignored provider event from ${providerId} to channel ${this.getChannelData().id}`);
+    }
+  }
+  async endpointRequest(_endpoint, _req, _res) {
+  }
+  async websocketRequest(_newWebSocket) {
+  }
+  async processCommand(webSocket, instanceMessage) {
+    if (instanceMessage.flow === import_kwirth_common.EInstanceMessageFlow.IMMEDIATE) {
+      let resp = await this.executeImmediateCommand(instanceMessage);
+      if (resp) webSocket.send(JSON.stringify(resp));
+      return Boolean(resp);
+    } else {
+      return false;
+    }
+  }
+  async executeImmediateCommand(instanceMessage) {
+    this.backChannelObject.logInfo?.("Immediate request received");
+    let iconfig = {
+      objects: import_kwirth_common.EInstanceConfigObject.PODS,
+      accessKey: "",
+      scope: "",
+      view: import_kwirth_common.EInstanceConfigView.NONE,
+      namespace: "",
+      group: "",
+      pod: "",
+      container: "",
+      action: import_kwirth_common.EInstanceMessageAction.NONE,
+      flow: import_kwirth_common.EInstanceMessageFlow.IMMEDIATE,
+      type: import_kwirth_common.EInstanceMessageType.DATA,
+      channel: "",
+      instance: ""
+    };
+    let instance = {
+      instanceId: instanceMessage.instance,
+      timeout: void 0,
+      working: false,
+      paused: false,
+      assets: [],
+      instanceConfig: iconfig,
+      interval: 0
+    };
+    let metricsMessageResponse = {
+      msgtype: "metricsmessageresponse",
+      action: import_kwirth_common.EInstanceMessageAction.NONE,
+      flow: import_kwirth_common.EInstanceMessageFlow.UNSOLICITED,
+      channel: import_kwirth_common.EInstanceMessageChannel.METRICS,
+      type: import_kwirth_common.EInstanceMessageType.DATA,
+      instance: iconfig.instance,
+      assets: [],
+      namespace: iconfig.namespace,
+      group: "",
+      pod: iconfig.pod,
+      timestamp: Date.now(),
+      container: ""
+    };
+    this.fillData(iconfig, instance, metricsMessageResponse);
+    return metricsMessageResponse;
+  }
+  // A connection counts while it carries an instance: one left with none is on its way out.
+  getInstances() {
+    const carrying = this.webSockets.filter((s) => s.instances.length > 0);
+    return { instances: carrying.reduce((n, s) => n + s.instances.length, 0), connections: carrying.length };
+  }
+  containsInstance(instanceId) {
+    for (var socket of this.webSockets) {
+      var exists = socket.instances.find((i) => i.instanceId === instanceId);
+      if (exists) return true;
+    }
+    return false;
+  }
+  stopInstance(webSocket, instanceConfig) {
+    let instance = this.getInstance(webSocket, instanceConfig.instance);
+    if (instance) {
+      this.removeInstance(webSocket, instanceConfig.instance);
+      this.sendInstanceConfigMessage(webSocket, import_kwirth_common.EInstanceMessageAction.STOP, import_kwirth_common.EInstanceMessageFlow.RESPONSE, import_kwirth_common.EInstanceMessageChannel.METRICS, instanceConfig, "Metrics instance stopped");
+    } else {
+      this.sendInstanceConfigMessage(webSocket, import_kwirth_common.EInstanceMessageAction.STOP, import_kwirth_common.EInstanceMessageFlow.RESPONSE, import_kwirth_common.EInstanceMessageChannel.METRICS, instanceConfig, "Instance not found");
+    }
+  }
+  modifyInstance(webSocket, instanceConfig) {
+    let instance = this.getInstance(webSocket, instanceConfig.instance);
+    if (instance) {
+      let destConfig = instance.instanceConfig.data;
+      destConfig.metrics = instanceConfig.data.metrics;
+      destConfig.interval = instanceConfig.data.interval;
+      destConfig.aggregate = instanceConfig.data.aggregate;
+      this.sendInstanceConfigMessage(webSocket, import_kwirth_common.EInstanceMessageAction.MODIFY, import_kwirth_common.EInstanceMessageFlow.RESPONSE, import_kwirth_common.EInstanceMessageChannel.METRICS, instanceConfig, "Metrics modified");
+    } else {
+      this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, `Instance ${instanceConfig.instance} not found`, instanceConfig);
+    }
+  }
+  pauseContinueInstance(webSocket, instanceConfig, action) {
+    let instance = this.getInstance(webSocket, instanceConfig.instance);
+    if (instance) {
+      if (action === import_kwirth_common.EInstanceMessageAction.PAUSE) {
+        instance.paused = true;
+        this.sendInstanceConfigMessage(webSocket, import_kwirth_common.EInstanceMessageAction.PAUSE, import_kwirth_common.EInstanceMessageFlow.RESPONSE, import_kwirth_common.EInstanceMessageChannel.METRICS, instanceConfig, "Metrics paused");
+      }
+      if (action === import_kwirth_common.EInstanceMessageAction.CONTINUE) {
+        instance.paused = false;
+        this.sendInstanceConfigMessage(webSocket, import_kwirth_common.EInstanceMessageAction.CONTINUE, import_kwirth_common.EInstanceMessageFlow.RESPONSE, import_kwirth_common.EInstanceMessageChannel.METRICS, instanceConfig, "Metrics continued");
+      }
+    } else {
+      this.sendChannelSignal(webSocket, import_kwirth_common.ESignalMessageLevel.ERROR, `Instance ${instanceConfig.instance} not found`, instanceConfig);
+    }
+  }
+  removeInstance(webSocket, instanceId) {
+    let socket = this.webSockets.find((entry) => entry.ws === webSocket);
+    if (socket) {
+      let instances = socket.instances;
+      if (instances) {
+        let instanceIndex = instances.findIndex((t) => t.instanceId === instanceId);
+        if (instanceIndex >= 0) {
+          if (instances[instanceIndex].timeout) clearInterval(instances[instanceIndex].timeout);
+          instances.splice(instanceIndex, 1);
+        } else {
+          this.backChannelObject.logInfo?.("Instance not found, cannot delete");
+        }
+      } else {
+        this.backChannelObject.logInfo?.("There are no Instances on websocket");
+      }
+    } else {
+      this.backChannelObject.logInfo?.("WebSocket not found on intervals");
+    }
+  }
+  containsConnection(webSocket) {
+    return Boolean(this.webSockets.find((s) => s.ws === webSocket));
+  }
+  refreshConnection(webSocket) {
+    let socket = this.webSockets.find((s) => s.ws === webSocket);
+    if (socket) {
+      socket.lastRefresh = Date.now();
+      return true;
+    } else {
+      this.backChannelObject.logInfo?.("WebSocket not found");
+      return false;
+    }
+  }
+  updateConnection(newWebSocket, instanceId) {
+    for (let entry of this.webSockets) {
+      var exists = entry.instances.find((i) => i.instanceId === instanceId);
+      if (exists) {
+        entry.ws = newWebSocket;
+        for (var instance of entry.instances) {
+          if (instance.timeout) clearInterval(instance.timeout);
+          instance.timeout = setInterval((w, i, s) => this.sendMetricsDataInstance(w, i, s), instance.interval, newWebSocket, instanceId, false);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  removeConnection(webSocket) {
+    let socket = this.webSockets.find((entry) => entry.ws === webSocket);
+    if (socket) {
+      const ids = socket.instances.map((i) => i.instanceId);
+      for (const id of ids) {
+        this.backChannelObject.logInfo?.(`Interval for instance ${id} has been removed`);
+        this.removeInstance(webSocket, id);
+      }
+      var pos = this.webSockets.findIndex((s) => s.ws === webSocket);
+      this.webSockets.splice(pos, 1);
+    }
+  }
+  // *************************************************************************************
+  // PRIVATE
+  // *************************************************************************************
+  getInstance(webSocket, instanceId) {
+    let socket = this.webSockets.find((entry) => entry.ws === webSocket);
+    if (socket) {
+      let instances = socket.instances;
+      if (instances) {
+        let instanceIndex = instances.findIndex((t) => t.instanceId === instanceId);
+        if (instanceIndex >= 0) return instances[instanceIndex];
+        this.backChannelObject.logInfo?.("Instance not found");
+      } else {
+        this.backChannelObject.logInfo?.("There are no Instances on websocket");
+      }
+    } else {
+      this.backChannelObject.logInfo?.("WebSocket not found");
+    }
+    return void 0;
+  }
+  sendChannelSignal(webSocket, level, text, instanceConfig) {
+    var signalMessage = {
+      action: import_kwirth_common.EInstanceMessageAction.NONE,
+      flow: import_kwirth_common.EInstanceMessageFlow.RESPONSE,
+      type: import_kwirth_common.EInstanceMessageType.SIGNAL,
+      level,
+      channel: instanceConfig.channel,
+      instance: instanceConfig.instance,
+      text
+    };
+    webSocket.send(JSON.stringify(signalMessage));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MetricsChannel
+});