@oneuptime/common 10.7.1 → 10.8.0

package/Tests/Types/Monitor/KubernetesAlertTemplates.test.ts

@@ -0,0 +1,193 @@
+import {
+  KubernetesAlertTemplate,
+  KubernetesAlertTemplateArgs,
+  getAllKubernetesAlertTemplates,
+  getKubernetesAlertTemplateById,
+} from "../../../Types/Monitor/KubernetesAlertTemplates";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorStepKubernetesMonitor from "../../../Types/Monitor/MonitorStepKubernetesMonitor";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * These tests lock in the subtle, easy-to-regress decisions in the per-node
+ * ratio alert templates (request utilization + usage utilization):
+ *
+ *   1. Group-by uses the ClickHouse-stored `resource.`-prefixed attribute
+ *      name (`resource.k8s.node.name`), not the bare `k8s.node.name`.
+ *      OneUptime stamps OTel resource attributes with a `resource.` prefix
+ *      at ingest, so the bare key would match nothing and collapse every
+ *      node into one mislabeled series.
+ *
+ *   2. The aggregation differs by numerator shape:
+ *        - Request utilization sums MANY container series per node, and both
+ *          metrics come from the same `k8s_cluster` scrape, so `Sum` on both
+ *          sides totals the containers and the scrape multiple cancels.
+ *        - Usage utilization has ONE series per node, and numerator
+ *          (kubeletstats) and denominator (k8s_cluster) come from different
+ *          receivers, so `Avg` on both sides gives the correct per-minute
+ *          ratio regardless of each receiver's scrape count.
+ *
+ *   3. The criteria reference the FORMULA alias (the computed percentage),
+ *      not a raw query alias.
+ */
+
+interface RatioTemplateCase {
+  id: string;
+  numerator: string;
+  denominator: string;
+  numAlias: string;
+  denAlias: string;
+  resultAlias: string;
+  aggregation: MetricsAggregationType;
+  threshold: number;
+}
+
+const RATIO_TEMPLATES: Array<RatioTemplateCase> = [
+  // Request utilization — Sum/Sum (numerator totals many containers per node).
+  {
+    id: "k8s-node-cpu-request-utilization",
+    numerator: "k8s.container.cpu_request",
+    denominator: "k8s.node.allocatable_cpu",
+    numAlias: "req_cpu",
+    denAlias: "alloc_cpu",
+    resultAlias: "node_cpu_request_utilization",
+    aggregation: MetricsAggregationType.Sum,
+    threshold: 90,
+  },
+  {
+    id: "k8s-node-memory-request-utilization",
+    numerator: "k8s.container.memory_request",
+    denominator: "k8s.node.allocatable_memory",
+    numAlias: "req_mem",
+    denAlias: "alloc_mem",
+    resultAlias: "node_memory_request_utilization",
+    aggregation: MetricsAggregationType.Sum,
+    threshold: 90,
+  },
+  // Usage utilization — Avg/Avg (one series per node, cross-receiver).
+  {
+    id: "k8s-high-cpu",
+    numerator: "k8s.node.cpu.usage",
+    denominator: "k8s.node.allocatable_cpu",
+    numAlias: "used_cpu",
+    denAlias: "alloc_cpu",
+    resultAlias: "node_cpu_utilization",
+    aggregation: MetricsAggregationType.Avg,
+    threshold: 90,
+  },
+  {
+    id: "k8s-high-memory",
+    numerator: "k8s.node.memory.usage",
+    denominator: "k8s.node.allocatable_memory",
+    numAlias: "used_mem",
+    denAlias: "alloc_mem",
+    resultAlias: "node_memory_utilization",
+    aggregation: MetricsAggregationType.Avg,
+    threshold: 85,
+  },
+];
+
+function buildArgs(): KubernetesAlertTemplateArgs {
+  return {
+    clusterIdentifier: "prod-cluster",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test Monitor",
+  };
+}
+
+function getKubernetesMonitor(step: MonitorStep): MonitorStepKubernetesMonitor {
+  const kubernetesMonitor: MonitorStepKubernetesMonitor | undefined =
+    step.data?.kubernetesMonitor;
+  if (!kubernetesMonitor) {
+    throw new Error("kubernetesMonitor missing from monitor step");
+  }
+  return kubernetesMonitor;
+}
+
+describe("KubernetesAlertTemplates - per-node ratio templates", () => {
+  test("all four ratio templates are registered", () => {
+    const ids: Array<string> = getAllKubernetesAlertTemplates().map(
+      (t: KubernetesAlertTemplate) => {
+        return t.id;
+      },
+    );
+    for (const tc of RATIO_TEMPLATES) {
+      expect(ids).toContain(tc.id);
+    }
+  });
+
+  test.each(RATIO_TEMPLATES)(
+    "$id is a per-node ($aggregation/$aggregation) ratio keyed on resource.k8s.node.name",
+    (tc: RatioTemplateCase) => {
+      const template: KubernetesAlertTemplate | undefined =
+        getKubernetesAlertTemplateById(tc.id);
+      expect(template).toBeDefined();
+
+      const step: MonitorStep = template!.getMonitorStep(buildArgs());
+      const monitor: MonitorStepKubernetesMonitor = getKubernetesMonitor(step);
+
+      const queryConfigs: Array<any> = monitor.metricViewConfig
+        .queryConfigs as Array<any>;
+      const formulaConfigs: Array<any> = monitor.metricViewConfig
+        .formulaConfigs as Array<any>;
+
+      // Two queries (numerator + denominator) and one formula.
+      expect(queryConfigs).toHaveLength(2);
+      expect(formulaConfigs).toHaveLength(1);
+
+      const [numerator, denominator] = queryConfigs;
+
+      // Metric names.
+      expect(numerator.metricQueryData.filterData.metricName).toBe(
+        tc.numerator,
+      );
+      expect(denominator.metricQueryData.filterData.metricName).toBe(
+        tc.denominator,
+      );
+
+      /*
+       * Decision (2): both sides use the same aggregation — Sum for request
+       * utilization (totals containers, cancels scrape factor) or Avg for
+       * usage utilization (one series per node, cross-receiver).
+       */
+      expect(numerator.metricQueryData.filterData.aggegationType).toBe(
+        tc.aggregation,
+      );
+      expect(denominator.metricQueryData.filterData.aggegationType).toBe(
+        tc.aggregation,
+      );
+
+      /*
+       * Decision (1): group by the resource-prefixed node attribute on BOTH
+       * queries so the per-series fingerprints line up for the formula join.
+       */
+      expect(numerator.metricQueryData.groupByAttributeKeys).toEqual([
+        "resource.k8s.node.name",
+      ]);
+      expect(denominator.metricQueryData.groupByAttributeKeys).toEqual([
+        "resource.k8s.node.name",
+      ]);
+
+      // Formula divides numerator by denominator and scales to a percentage.
+      expect(formulaConfigs[0].metricFormulaData.metricFormula).toBe(
+        `(${tc.numAlias} / ${tc.denAlias}) * 100`,
+      );
+
+      /*
+       * Decision (3): the criteria must reference the FORMULA alias (not a
+       * raw query), so the threshold is evaluated against the computed
+       * percentage.
+       */
+      const offlineFilters: Array<any> = step.data?.monitorCriteria.data
+        ?.monitorCriteriaInstanceArray?.[0]?.data?.filters as Array<any>;
+      expect(offlineFilters[0].metricMonitorOptions.metricAlias).toBe(
+        tc.resultAlias,
+      );
+      expect(offlineFilters[0].value).toBe(tc.threshold);
+    },
+  );
+});

package/Tests/UI/Components/DuplicateModel.test.tsx

@@ -236,7 +236,7 @@ describe("DuplicateModel", () => {
     );
     expect(
       within(errorDialog).getByTestId("confirm-modal-description")?.textContent,
-    ).toBe("Error: Could not create Foo");
+    ).toBe("Could not create Foo");
     expect(
       within(errorDialog).getByTestId("modal-footer-submit-button")
         ?.textContent,
@@ -274,7 +274,7 @@ describe("DuplicateModel", () => {
     );
     expect(
       within(errorDialog).getByTestId("confirm-modal-description")?.textContent,
-    ).toBe("Error: Could not find Foo with id foo");
+    ).toBe("Could not find Foo with id foo");
     expect(
       within(errorDialog).getByTestId("modal-footer-submit-button")
         ?.textContent,

package/Types/Monitor/KubernetesAlertTemplates.ts

@@ -221,6 +221,111 @@ export function buildKubernetesMonitorConfig(args: {
   };
 }
 
+/**
+ * Build a per-series ratio monitor: `(numerator / denominator) * 100`,
+ * grouped by a single OpenTelemetry attribute so one incident fires per
+ * group (e.g. per node).
+ *
+ * Used for saturation metrics that aren't emitted as a single ready-made
+ * series — e.g. node request utilization (summed pod requests ÷ node
+ * allocatable) and node usage utilization (node usage ÷ node allocatable),
+ * neither of which the kubeletstats receiver exposes as a percentage.
+ *
+ * Aggregation (`aggregationType`, default `Sum`) — the per-series worker
+ * buckets raw rows by (group, minute) and applies this aggregation to
+ * EVERY row in the bucket, i.e. across both the grouped entities AND the
+ * scrapes in that minute. Pick it based on the numerator:
+ *
+ *   - `Sum` when the numerator must be totalled across multiple series per
+ *     group (e.g. summing every container's request on a node). The scrape
+ *     multiple then has to cancel, so numerator and denominator must ride
+ *     the SAME receiver/scrape — true for the request-utilization
+ *     templates, where both metrics come from `k8s_cluster`:
+ *     `(Σrequests × scrapes) / (allocatable × scrapes)`.
+ *
+ *   - `Avg` when the numerator is already ONE series per group (e.g.
+ *     `k8s.node.cpu.usage`). Avg yields the representative per-minute value
+ *     independent of scrape count, so it stays correct even when numerator
+ *     and denominator come from DIFFERENT receivers on independent scrape
+ *     cycles (node usage is from the kubeletstats DaemonSet; allocatable is
+ *     from the `k8s_cluster` Deployment). `Sum` there would only cancel if
+ *     both reported the same row count every minute — fragile across
+ *     restarts / missed scrapes / minute-boundary jitter.
+ *
+ * The group-by key is the ClickHouse-stored attribute name, which carries
+ * the `resource.` prefix for OTel resource attributes (see
+ * OtelMetricsIngestService — resource attributes are stamped with
+ * `prefixKeysWithString: "resource"`). So node grouping is
+ * `resource.k8s.node.name`, not the bare `k8s.node.name`.
+ */
+export function buildKubernetesRatioMonitorConfig(args: {
+  clusterIdentifier: string;
+  numeratorMetricName: string;
+  denominatorMetricName: string;
+  groupByAttributeKey: string;
+  numeratorAlias: string;
+  denominatorAlias: string;
+  resultAlias: string;
+  resultLegend: string;
+  resourceScope: KubernetesResourceScope;
+  rollingTime: RollingTime;
+  aggregationType?: MetricsAggregationType | undefined;
+}): MonitorStepKubernetesMonitor {
+  const aggregationType: MetricsAggregationType =
+    args.aggregationType || MetricsAggregationType.Sum;
+
+  const buildQueryConfig: (alias: string, metricName: string) => any = (
+    alias: string,
+    metricName: string,
+  ): any => {
+    return {
+      metricAliasData: {
+        metricVariable: alias,
+        title: alias,
+        description: alias,
+        legend: alias,
+        legendUnit: undefined,
+      },
+      metricQueryData: {
+        filterData: {
+          metricName: metricName,
+          attributes: {},
+          aggegationType: aggregationType,
+          aggregateBy: {},
+        },
+        groupByAttributeKeys: [args.groupByAttributeKey],
+      },
+    };
+  };
+
+  return {
+    clusterIdentifier: args.clusterIdentifier,
+    resourceScope: args.resourceScope,
+    resourceFilters: {},
+    metricViewConfig: {
+      queryConfigs: [
+        buildQueryConfig(args.numeratorAlias, args.numeratorMetricName),
+        buildQueryConfig(args.denominatorAlias, args.denominatorMetricName),
+      ],
+      formulaConfigs: [
+        {
+          metricAliasData: {
+            metricVariable: args.resultAlias,
+            title: args.resultLegend,
+            description: args.resultLegend,
+            legend: args.resultLegend,
+            legendUnit: "%",
+          },
+          metricFormulaData: {
+            metricFormula: `(${args.numeratorAlias} / ${args.denominatorAlias}) * 100`,
+          },
+        },
+      ],
+    },
+    rollingTime: args.rollingTime,
+  };
+}
+
 // --- Template Definitions ---
 
 const crashLoopBackOffTemplate: KubernetesAlertTemplate = {
@@ -356,19 +461,31 @@ const nodeNotReadyTemplate: KubernetesAlertTemplate = {
 const highCpuTemplate: KubernetesAlertTemplate = {
   id: "k8s-high-cpu",
   name: "High Node CPU Utilization",
-  description: "Alert when node CPU utilization exceeds 90% sustained.",
+  description:
+    "Alert when a node's average CPU usage exceeds 90% of its allocatable CPU. Computed per node as k8s.node.cpu.usage ÷ k8s.node.allocatable_cpu × 100 — both are cores, so this is a true percentage (the raw k8s.node.cpu.utilization metric is a misnamed cores gauge, not a percent).",
   category: "Node",
   severity: "Warning",
   getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
-    const metricAlias: string = "node_cpu";
+    const metricAlias: string = "node_cpu_utilization";
 
     return buildKubernetesMonitorStep({
-      kubernetesMonitor: buildKubernetesMonitorConfig({
+      kubernetesMonitor: buildKubernetesRatioMonitorConfig({
         clusterIdentifier: args.clusterIdentifier,
-        metricName: "k8s.node.cpu.utilization",
-        metricAlias,
+        numeratorMetricName: "k8s.node.cpu.usage",
+        denominatorMetricName: "k8s.node.allocatable_cpu",
+        groupByAttributeKey: "resource.k8s.node.name",
+        numeratorAlias: "used_cpu",
+        denominatorAlias: "alloc_cpu",
+        resultAlias: metricAlias,
+        resultLegend: "Node CPU Utilization (%)",
         resourceScope: KubernetesResourceScope.Node,
         rollingTime: RollingTime.Past5Minutes,
+        /*
+         * Single series per node from two DIFFERENT receivers (usage =
+         * kubeletstats, allocatable = k8s_cluster) — Avg keeps the per-minute
+         * ratio correct regardless of each receiver's scrape count. See
+         * buildKubernetesRatioMonitorConfig.
+         */
         aggregationType: MetricsAggregationType.Avg,
       }),
       offlineCriteriaInstance: buildOfflineCriteriaInstance({
@@ -380,10 +497,10 @@ const highCpuTemplate: KubernetesAlertTemplate = {
         filterType: FilterType.GreaterThan,
         value: 90,
         incidentTitle: `[K8s] High CPU Utilization (>90%) - ${args.monitorName}`,
-        incidentDescription: `Node CPU utilization has exceeded 90% in the Kubernetes cluster. Sustained high CPU usage can cause pod throttling, increased latency, and potential node instability. Check the root cause for the specific node and top CPU-consuming workloads.`,
+        incidentDescription: `A node's average CPU usage has exceeded 90% of its allocatable CPU. Sustained high CPU usage can cause pod throttling, increased latency, and potential node instability. Check the root cause for the specific node and top CPU-consuming workloads.`,
         criteriaName: "High CPU - Utilization > 90%",
         criteriaDescription:
-          "Triggers when average node CPU utilization exceeds 90% over the monitoring window.",
+          "Triggers when a node's average CPU usage exceeds 90% of its allocatable CPU over the monitoring window.",
       }),
       onlineCriteriaInstance: buildOnlineCriteriaInstance({
         onlineMonitorStatusId: args.onlineMonitorStatusId,
@@ -398,19 +515,31 @@ const highCpuTemplate: KubernetesAlertTemplate = {
 const highMemoryTemplate: KubernetesAlertTemplate = {
   id: "k8s-high-memory",
   name: "High Node Memory Utilization",
-  description: "Alert when node memory utilization exceeds 85% sustained.",
+  description:
+    "Alert when a node's average memory usage exceeds 85% of its allocatable memory. Computed per node as k8s.node.memory.usage ÷ k8s.node.allocatable_memory × 100 — both are bytes, so this is a true percentage (the raw k8s.node.memory.usage metric is bytes, not a percent).",
   category: "Node",
   severity: "Warning",
   getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
-    const metricAlias: string = "node_memory";
+    const metricAlias: string = "node_memory_utilization";
 
     return buildKubernetesMonitorStep({
-      kubernetesMonitor: buildKubernetesMonitorConfig({
+      kubernetesMonitor: buildKubernetesRatioMonitorConfig({
         clusterIdentifier: args.clusterIdentifier,
-        metricName: "k8s.node.memory.usage",
-        metricAlias,
+        numeratorMetricName: "k8s.node.memory.usage",
+        denominatorMetricName: "k8s.node.allocatable_memory",
+        groupByAttributeKey: "resource.k8s.node.name",
+        numeratorAlias: "used_mem",
+        denominatorAlias: "alloc_mem",
+        resultAlias: metricAlias,
+        resultLegend: "Node Memory Utilization (%)",
         resourceScope: KubernetesResourceScope.Node,
         rollingTime: RollingTime.Past5Minutes,
+        /*
+         * Single series per node from two DIFFERENT receivers (usage =
+         * kubeletstats, allocatable = k8s_cluster) — Avg keeps the per-minute
+         * ratio correct regardless of each receiver's scrape count. See
+         * buildKubernetesRatioMonitorConfig.
+         */
         aggregationType: MetricsAggregationType.Avg,
       }),
       offlineCriteriaInstance: buildOfflineCriteriaInstance({
@@ -422,10 +551,10 @@ const highMemoryTemplate: KubernetesAlertTemplate = {
         filterType: FilterType.GreaterThan,
         value: 85,
         incidentTitle: `[K8s] High Memory Utilization (>85%) - ${args.monitorName}`,
-        incidentDescription: `Node memory utilization has exceeded 85% in the Kubernetes cluster. High memory usage can lead to OOMKilled pods, node instability, and potential evictions. Check the root cause for the specific node and top memory-consuming workloads.`,
+        incidentDescription: `A node's average memory usage has exceeded 85% of its allocatable memory. High memory usage can lead to OOMKilled pods, node instability, and potential evictions. Check the root cause for the specific node and top memory-consuming workloads.`,
         criteriaName: "High Memory - Utilization > 85%",
         criteriaDescription:
-          "Triggers when average node memory utilization exceeds 85% over the monitoring window.",
+          "Triggers when a node's average memory usage exceeds 85% of its allocatable memory over the monitoring window.",
       }),
       onlineCriteriaInstance: buildOnlineCriteriaInstance({
         onlineMonitorStatusId: args.onlineMonitorStatusId,
@@ -736,6 +865,100 @@ const daemonSetUnavailableTemplate: KubernetesAlertTemplate = {
   },
 };
 
+const nodeCpuRequestUtilizationTemplate: KubernetesAlertTemplate = {
+  id: "k8s-node-cpu-request-utilization",
+  name: "High Node CPU Request Commitment",
+  description:
+    "Alert when a node's committed CPU requests exceed 90% of its allocatable CPU. Derived per node from summed container CPU requests over node allocatable CPU — both collected by default via the k8s_cluster receiver. A near-full node can't schedule new pods even if actual CPU usage is low.",
+  category: "Node",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "node_cpu_request_utilization";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesRatioMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        numeratorMetricName: "k8s.container.cpu_request",
+        denominatorMetricName: "k8s.node.allocatable_cpu",
+        groupByAttributeKey: "resource.k8s.node.name",
+        numeratorAlias: "req_cpu",
+        denominatorAlias: "alloc_cpu",
+        resultAlias: metricAlias,
+        resultLegend: "Node CPU Request Utilization (%)",
+        resourceScope: KubernetesResourceScope.Node,
+        rollingTime: RollingTime.Past5Minutes,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 90,
+        incidentTitle: `[K8s] High Node CPU Request Commitment (>90%) - ${args.monitorName}`,
+        incidentDescription: `A node's committed CPU requests have exceeded 90% of its allocatable CPU. The node is nearly full from a scheduling standpoint and may be unable to place new pods, even if current CPU usage is low. Check the root cause for the specific node and its top CPU-requesting workloads.`,
+        criteriaName: "High CPU Request Commitment - Utilization > 90%",
+        criteriaDescription:
+          "Triggers when any node's summed container CPU requests exceed 90% of its allocatable CPU.",
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 90,
+      }),
+    });
+  },
+};
+
+const nodeMemoryRequestUtilizationTemplate: KubernetesAlertTemplate = {
+  id: "k8s-node-memory-request-utilization",
+  name: "High Node Memory Request Commitment",
+  description:
+    "Alert when a node's committed memory requests exceed 90% of its allocatable memory. Derived per node from summed container memory requests over node allocatable memory — both collected by default via the k8s_cluster receiver. A near-full node can't schedule new pods even if actual memory usage is low.",
+  category: "Node",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "node_memory_request_utilization";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesRatioMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        numeratorMetricName: "k8s.container.memory_request",
+        denominatorMetricName: "k8s.node.allocatable_memory",
+        groupByAttributeKey: "resource.k8s.node.name",
+        numeratorAlias: "req_mem",
+        denominatorAlias: "alloc_mem",
+        resultAlias: metricAlias,
+        resultLegend: "Node Memory Request Utilization (%)",
+        resourceScope: KubernetesResourceScope.Node,
+        rollingTime: RollingTime.Past5Minutes,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 90,
+        incidentTitle: `[K8s] High Node Memory Request Commitment (>90%) - ${args.monitorName}`,
+        incidentDescription: `A node's committed memory requests have exceeded 90% of its allocatable memory. The node is nearly full from a scheduling standpoint and may be unable to place new pods, even if current memory usage is low. Check the root cause for the specific node and its top memory-requesting workloads.`,
+        criteriaName: "High Memory Request Commitment - Utilization > 90%",
+        criteriaDescription:
+          "Triggers when any node's summed container memory requests exceed 90% of its allocatable memory.",
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 90,
+      }),
+    });
+  },
+};
+
 export function getAllKubernetesAlertTemplates(): Array<KubernetesAlertTemplate> {
   return [
     crashLoopBackOffTemplate,
@@ -750,6 +973,8 @@ export function getAllKubernetesAlertTemplates(): Array<KubernetesAlertTemplate>
     schedulerBacklogTemplate,
     highDiskUsageTemplate,
     daemonSetUnavailableTemplate,
+    nodeCpuRequestUtilizationTemplate,
+    nodeMemoryRequestUtilizationTemplate,
   ];
 }