@oneuptime/common 11.7.4 → 12.0.0

package/Tests/Types/Kubernetes/KubernetesRightSizing.test.ts

@@ -0,0 +1,323 @@
+import {
+  MIN_RECOMMENDED_CPU_CORES,
+  MIN_RECOMMENDED_MEMORY_BYTES,
+  RightSizingObservation,
+  RightSizingRecommendation,
+  RightSizingVerdict,
+  buildRightSizingRecommendation,
+  formatCpuCores,
+  formatMemoryBytes,
+  hasActionableRecommendation,
+} from "../../../Types/Kubernetes/KubernetesRightSizing";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Right-sizing turns cost-window aggregates into "set this request to that".
+ * The dangerous failure is not an imprecise saving — it is advising a memory
+ * request below what a container actually peaked at, which turns into an
+ * OOMKill in production. So the tests below lean hardest on the cases where
+ * the recommendation must refuse to answer.
+ */
+
+const MIB: number = 1024 * 1024;
+const GIB: number = 1024 * MIB;
+
+// A week of hourly windows for a single replica.
+const WEEK_HOURS: number = 168;
+
+function observation(
+  overrides: Partial<RightSizingObservation> = {},
+): RightSizingObservation {
+  return {
+    namespace: "prod",
+    controllerKind: "Deployment",
+    controllerName: "api",
+    containerName: "api",
+    sampleCount: WEEK_HOURS,
+    cpuCoreRequestAverage: 1,
+    cpuCoreUsageP95: 0.2,
+    cpuCost: 10,
+    ramBytesRequestAverage: GIB,
+    ramBytesUsagePeak: 256 * MIB,
+    ramCost: 6,
+    ...overrides,
+  };
+}
+
+describe("buildRightSizingRecommendation - CPU", () => {
+  test("flags an over-provisioned request and sizes it from P95 plus headroom", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ cpuCoreRequestAverage: 1, cpuCoreUsageP95: 0.2 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Overprovisioned);
+    // 0.2 * 1.25 = 0.25 cores, already on a 10m boundary.
+    expect(result.cpu.recommended).toBeCloseTo(0.25, 5);
+    expect(result.cpu.current).toBe(1);
+  });
+
+  test("rounds the recommendation up to the next 10 millicores", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ cpuCoreUsageP95: 0.101 }),
+      WEEK_HOURS,
+    );
+
+    // 0.101 * 1.25 = 0.12625 -> 0.13
+    expect(result.cpu.recommended).toBeCloseTo(0.13, 5);
+  });
+
+  test("flags an under-provisioned request", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ cpuCoreRequestAverage: 0.1, cpuCoreUsageP95: 0.5 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Underprovisioned);
+    expect(result.cpu.recommended).toBeCloseTo(0.63, 5);
+  });
+
+  test("leaves a request inside the significance band alone", () => {
+    // 0.8 * 1.25 = 1.0 exactly, so the request is already right.
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ cpuCoreRequestAverage: 1, cpuCoreUsageP95: 0.8 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Optimal);
+    expect(result.cpu.costDeltaInWindow).toBe(0);
+  });
+
+  test("never recommends below the CPU floor", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ cpuCoreRequestAverage: 0.5, cpuCoreUsageP95: 0.0001 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.recommended).toBe(MIN_RECOMMENDED_CPU_CORES);
+  });
+
+  test("reports a container with no request as a scheduling problem, not a saving", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({
+        cpuCoreRequestAverage: 0,
+        cpuCoreUsageP95: 0.4,
+        ramBytesRequestAverage: 0,
+      }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.NoRequestSet);
+    expect(result.cpu.current).toBeNull();
+    expect(result.cpu.recommended).toBeCloseTo(0.5, 5);
+    expect(result.cpu.costDeltaInWindow).toBe(0);
+    expect(result.estimatedMonthlySavings).toBe(0);
+  });
+});
+
+describe("buildRightSizingRecommendation - memory", () => {
+  test("sizes memory from the peak, not the request", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({
+        ramBytesRequestAverage: GIB,
+        ramBytesUsagePeak: 256 * MIB,
+      }),
+      WEEK_HOURS,
+    );
+
+    expect(result.memory.verdict).toBe(RightSizingVerdict.Overprovisioned);
+    // 256Mi * 1.25 = 320Mi, already a multiple of the 16Mi step.
+    expect(result.memory.recommended).toBe(320 * MIB);
+  });
+
+  test("refuses to size memory when no peak was reported", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ ramBytesUsagePeak: 0 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.memory.verdict).toBe(RightSizingVerdict.Unavailable);
+    expect(result.memory.recommended).toBeNull();
+    expect(result.memory.costDeltaInWindow).toBe(0);
+    expect(result.memory.unavailableReason).toContain("Prometheus");
+  });
+
+  test("a missing memory peak does not block the CPU recommendation", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ ramBytesUsagePeak: 0 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Overprovisioned);
+    expect(result.estimatedMonthlySavings).toBeGreaterThan(0);
+  });
+
+  test("rounds memory up to the next 16Mi", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ ramBytesUsagePeak: 100 * MIB }),
+      WEEK_HOURS,
+    );
+
+    // 100Mi * 1.25 = 125Mi -> 128Mi
+    expect(result.memory.recommended).toBe(128 * MIB);
+  });
+
+  test("never recommends below the memory floor", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ ramBytesUsagePeak: 1024 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.memory.recommended).toBe(MIN_RECOMMENDED_MEMORY_BYTES);
+  });
+});
+
+describe("buildRightSizingRecommendation - confidence gate", () => {
+  test("advises nothing when the window is shorter than a day", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ sampleCount: 4 }),
+      4,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Unavailable);
+    expect(result.memory.verdict).toBe(RightSizingVerdict.Unavailable);
+    expect(result.estimatedMonthlySavings).toBe(0);
+    expect(hasActionableRecommendation(result)).toBe(false);
+  });
+
+  test("advises nothing when a long window holds only a few samples", () => {
+    // A workload that existed for two hours of a week-long window.
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ sampleCount: 2 }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Unavailable);
+    expect(result.cpu.unavailableReason).toContain("at least a day");
+  });
+});
+
+describe("buildRightSizingRecommendation - savings", () => {
+  test("scales the window saving to a month", () => {
+    /*
+     * CPU: request 1 core, P95 0.2 -> recommend 0.25, so 75% of $10 goes.
+     * RAM: request 1Gi, peak 256Mi -> recommend 320Mi, so 68.75% of $6 goes.
+     * Window saving = 7.5 + 4.125 = 11.625 over 168h; a 730h month is
+     * 4.3452... times that window.
+     */
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation(),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.costDeltaInWindow).toBeCloseTo(-7.5, 5);
+    expect(result.memory.costDeltaInWindow).toBeCloseTo(-4.125, 5);
+    expect(result.estimatedMonthlySavings).toBeCloseTo(11.625 * (730 / 168), 4);
+    expect(result.estimatedMonthlyIncrease).toBe(0);
+  });
+
+  test("an under-provisioned workload reports an increase, never a saving", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({
+        cpuCoreRequestAverage: 0.1,
+        cpuCoreUsageP95: 0.5,
+        ramBytesRequestAverage: 64 * MIB,
+        ramBytesUsagePeak: 512 * MIB,
+      }),
+      WEEK_HOURS,
+    );
+
+    expect(result.estimatedMonthlySavings).toBe(0);
+    expect(result.estimatedMonthlyIncrease).toBeGreaterThan(0);
+  });
+
+  test("prices the increase off actual usage when usage already exceeds the request", () => {
+    /*
+     * Request 0.1 but P95 usage 0.5: the engine already bills for 0.5, so
+     * moving to a 0.63 request costs 26% more, not 530% more.
+     */
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({
+        cpuCoreRequestAverage: 0.1,
+        cpuCoreUsageP95: 0.5,
+        cpuCost: 10,
+        ramBytesUsagePeak: 0,
+      }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.costDeltaInWindow).toBeCloseTo(10 * (0.63 / 0.5 - 1), 5);
+  });
+
+  test("a replica count in sampleCount does not inflate the monthly projection", () => {
+    // Same window, same spend, three replicas' worth of rows.
+    const single: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ sampleCount: WEEK_HOURS }),
+      WEEK_HOURS,
+    );
+    const triple: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({ sampleCount: WEEK_HOURS * 3 }),
+      WEEK_HOURS,
+    );
+
+    expect(triple.estimatedMonthlySavings).toBeCloseTo(
+      single.estimatedMonthlySavings,
+      5,
+    );
+  });
+});
+
+describe("hasActionableRecommendation", () => {
+  test("is false when both resources are already right-sized", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({
+        cpuCoreRequestAverage: 1,
+        cpuCoreUsageP95: 0.8,
+        ramBytesRequestAverage: 320 * MIB,
+        ramBytesUsagePeak: 256 * MIB,
+      }),
+      WEEK_HOURS,
+    );
+
+    expect(result.cpu.verdict).toBe(RightSizingVerdict.Optimal);
+    expect(result.memory.verdict).toBe(RightSizingVerdict.Optimal);
+    expect(hasActionableRecommendation(result)).toBe(false);
+  });
+
+  test("is true when only one resource needs a change", () => {
+    const result: RightSizingRecommendation = buildRightSizingRecommendation(
+      observation({
+        cpuCoreRequestAverage: 1,
+        cpuCoreUsageP95: 0.8,
+        ramBytesRequestAverage: GIB,
+        ramBytesUsagePeak: 128 * MIB,
+      }),
+      WEEK_HOURS,
+    );
+
+    expect(hasActionableRecommendation(result)).toBe(true);
+  });
+});
+
+describe("formatting", () => {
+  test("writes sub-core CPU as millicores", () => {
+    expect(formatCpuCores(0.25)).toBe("250m");
+    expect(formatCpuCores(0.01)).toBe("10m");
+  });
+
+  test("writes whole cores as decimals", () => {
+    expect(formatCpuCores(1)).toBe("1");
+    expect(formatCpuCores(2.5)).toBe("2.5");
+  });
+
+  test("writes memory as Kubernetes binary quantities", () => {
+    expect(formatMemoryBytes(320 * MIB)).toBe("320Mi");
+    expect(formatMemoryBytes(2 * GIB)).toBe("2Gi");
+    expect(formatMemoryBytes(1.5 * GIB)).toBe("1.5Gi");
+  });
+
+  test("renders unknown values as a dash", () => {
+    expect(formatCpuCores(null)).toBe("-");
+    expect(formatMemoryBytes(null)).toBe("-");
+  });
+});

package/Tests/Types/Metrics/MetricDownsamplingRetentionDays.test.ts

@@ -0,0 +1,77 @@
+import MetricDownsamplingRetentionDays, {
+  DEFAULT_METRIC_CARDINALITY_BUDGET,
+  DEFAULT_METRIC_DOWNSAMPLING_RETENTION_DAYS,
+  resolveTierRetentionDays,
+} from "../../../Types/Metrics/MetricDownsamplingRetentionDays";
+import { describe, expect, test } from "@jest/globals";
+
+describe("MetricDownsamplingRetentionDays", () => {
+  describe("defaults", () => {
+    test("exposes the documented per-tier default retention", () => {
+      expect(DEFAULT_METRIC_DOWNSAMPLING_RETENTION_DAYS).toEqual({
+        raw: 7,
+        "1m": 14,
+        "5m": 30,
+        "1h": 90,
+        "1d": 365,
+      });
+    });
+
+    test("exposes the default cardinality budget", () => {
+      expect(DEFAULT_METRIC_CARDINALITY_BUDGET).toBe(10000);
+    });
+  });
+
+  describe("resolveTierRetentionDays", () => {
+    test("prefers a positive service override over everything else", () => {
+      const serviceOverride: MetricDownsamplingRetentionDays = { raw: 3 };
+      const projectDefault: MetricDownsamplingRetentionDays = { raw: 20 };
+
+      expect(
+        resolveTierRetentionDays("raw", serviceOverride, projectDefault),
+      ).toBe(3);
+    });
+
+    test("falls back to the project default when the service override is missing", () => {
+      const projectDefault: MetricDownsamplingRetentionDays = { "1m": 21 };
+
+      expect(resolveTierRetentionDays("1m", null, projectDefault)).toBe(21);
+      expect(resolveTierRetentionDays("1m", {}, projectDefault)).toBe(21);
+      expect(resolveTierRetentionDays("1m", undefined, projectDefault)).toBe(
+        21,
+      );
+    });
+
+    test("falls back to the hardcoded default when neither override is set", () => {
+      expect(resolveTierRetentionDays("5m", null, null)).toBe(30);
+      expect(resolveTierRetentionDays("1h", undefined, undefined)).toBe(90);
+      expect(resolveTierRetentionDays("1d", {}, {})).toBe(365);
+    });
+
+    test("ignores non-positive service values and continues the fallback chain", () => {
+      const projectDefault: MetricDownsamplingRetentionDays = { raw: 12 };
+
+      // 0 and negative must NOT win — they fall through to the project default.
+      expect(resolveTierRetentionDays("raw", { raw: 0 }, projectDefault)).toBe(
+        12,
+      );
+      expect(resolveTierRetentionDays("raw", { raw: -5 }, projectDefault)).toBe(
+        12,
+      );
+    });
+
+    test("ignores null service values and uses the project default", () => {
+      const projectDefault: MetricDownsamplingRetentionDays = { raw: 9 };
+
+      expect(
+        resolveTierRetentionDays("raw", { raw: null }, projectDefault),
+      ).toBe(9);
+    });
+
+    test("ignores a non-positive project default and uses the hardcoded default", () => {
+      // service missing, project default is 0 -> hardcoded default (7).
+      expect(resolveTierRetentionDays("raw", null, { raw: 0 })).toBe(7);
+      expect(resolveTierRetentionDays("raw", null, { raw: -1 })).toBe(7);
+    });
+  });
+});

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationCatalog.test.ts

@@ -16,6 +16,7 @@ import { getAllIoTAlertTemplates } from "../../../../Types/Monitor/IotAlertTempl
 import { getAllKubernetesAlertTemplates } from "../../../../Types/Monitor/KubernetesAlertTemplates";
 import { getAllPodmanAlertTemplates } from "../../../../Types/Monitor/PodmanAlertTemplates";
 import { getAllProxmoxAlertTemplates } from "../../../../Types/Monitor/ProxmoxAlertTemplates";
+import { getAllRumAlertTemplates } from "../../../../Types/Monitor/RumAlertTemplates";
 
 /*
  * The catalog is the seam between eight independently-maintained alert-template
@@ -41,63 +42,74 @@ import { getAllProxmoxAlertTemplates } from "../../../../Types/Monitor/ProxmoxAl
 
 interface ModuleExpectation {
   resourceType: MonitorRecommendationResourceType;
-  monitorType: MonitorType;
+  monitorTypes: Array<MonitorType>;
   templateCount: number;
   identifierFieldName:
     | "clusterIdentifier"
     | "hostIdentifier"
-    | "fleetIdentifier";
+    | "fleetIdentifier"
+    | "rumApplicationId";
 }
 
 const MODULE_EXPECTATIONS: Array<ModuleExpectation> = [
   {
     resourceType: MonitorRecommendationResourceType.Kubernetes,
-    monitorType: MonitorType.Kubernetes,
+    monitorTypes: [MonitorType.Kubernetes],
     templateCount: getAllKubernetesAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Host,
-    monitorType: MonitorType.Host,
+    monitorTypes: [MonitorType.Host],
     templateCount: getAllHostAlertTemplates().length,
     identifierFieldName: "hostIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Docker,
-    monitorType: MonitorType.Docker,
+    monitorTypes: [MonitorType.Docker],
     templateCount: getAllDockerAlertTemplates().length,
     identifierFieldName: "hostIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.DockerSwarm,
-    monitorType: MonitorType.DockerSwarm,
+    monitorTypes: [MonitorType.DockerSwarm],
     templateCount: getAllDockerSwarmAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Podman,
-    monitorType: MonitorType.Podman,
+    monitorTypes: [MonitorType.Podman],
     templateCount: getAllPodmanAlertTemplates().length,
     identifierFieldName: "hostIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Proxmox,
-    monitorType: MonitorType.Proxmox,
+    monitorTypes: [MonitorType.Proxmox],
     templateCount: getAllProxmoxAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Ceph,
-    monitorType: MonitorType.Ceph,
+    monitorTypes: [MonitorType.Ceph],
     templateCount: getAllCephAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.IoTDevice,
-    monitorType: MonitorType.IoTDevice,
+    monitorTypes: [MonitorType.IoTDevice],
     templateCount: getAllIoTAlertTemplates().length,
     identifierFieldName: "fleetIdentifier",
   },
+  {
+    resourceType: MonitorRecommendationResourceType.RumApplication,
+    monitorTypes: [
+      MonitorType.Metrics,
+      MonitorType.Traces,
+      MonitorType.Exceptions,
+    ],
+    templateCount: getAllRumAlertTemplates().length,
+    identifierFieldName: "rumApplicationId",
+  },
 ];
 
 describe("MonitorRecommendationCatalog", () => {
@@ -244,7 +256,7 @@ describe("MonitorRecommendationCatalog", () => {
   });
 
   describe("resource type definitions", () => {
-    it("maps each resource type to the correct MonitorType", () => {
+    it("maps each resource type to all MonitorTypes its recommendations use", () => {
       for (const expectation of MODULE_EXPECTATIONS) {
         const definition:
           | MonitorRecommendationResourceTypeDefinition
@@ -252,7 +264,7 @@ describe("MonitorRecommendationCatalog", () => {
           expectation.resourceType,
         );
 
-        expect(definition?.monitorType).toBe(expectation.monitorType);
+        expect(definition?.monitorTypes).toEqual(expectation.monitorTypes);
       }
     });
 
@@ -278,15 +290,31 @@ describe("MonitorRecommendationCatalog", () => {
       }
     });
 
-    it("stamps every recommendation with its definition's monitorType and resourceType", () => {
+    it("stamps every recommendation with one of its definition's monitorTypes and its resourceType", () => {
       for (const definition of MonitorRecommendationCatalog.getResourceTypeDefinitions()) {
         for (const recommendation of definition.getRecommendations()) {
-          expect(recommendation.monitorType).toBe(definition.monitorType);
+          expect(definition.monitorTypes).toContain(recommendation.monitorType);
           expect(recommendation.resourceType).toBe(definition.resourceType);
         }
       }
     });
 
+    it("declares no unused MonitorTypes on a resource definition", () => {
+      for (const definition of MonitorRecommendationCatalog.getResourceTypeDefinitions()) {
+        const usedTypes: Array<MonitorType> = Array.from(
+          new Set(
+            definition
+              .getRecommendations()
+              .map((recommendation: MonitorRecommendation) => {
+                return recommendation.monitorType;
+              }),
+          ),
+        );
+
+        expect([...definition.monitorTypes].sort()).toEqual(usedTypes.sort());
+      }
+    });
+
     it("gives every definition a non-empty human label", () => {
       for (const definition of MonitorRecommendationCatalog.getResourceTypeDefinitions()) {
         expect(definition.resourceLabel.trim().length).toBeGreaterThan(0);

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationCoverage.test.ts

@@ -46,7 +46,7 @@ const OFFLINE_STATUS_ID: ObjectID = ObjectID.generate();
 const INCIDENT_SEVERITY_ID: ObjectID = ObjectID.generate();
 const ALERT_SEVERITY_ID: ObjectID = ObjectID.generate();
 
-const RESOURCE_IDENTIFIER: string = "prod-cluster-01";
+const RESOURCE_IDENTIFIER: string = ObjectID.generate().toString();
 
 /*
  * Structurally identical to the inline element type
@@ -513,7 +513,7 @@ describe("MonitorRecommendationUtil.getCoveredRecommendationMonitorIds", () => {
      * both a covered and an uncovered answer are exercised for all eight
      * resource types.
      */
-    expect(RESOURCE_TYPE_DEFINITIONS.length).toBe(8);
+    expect(RESOURCE_TYPE_DEFINITIONS.length).toBe(9);
 
     for (const definition of RESOURCE_TYPE_DEFINITIONS) {
       const recommendations: Array<MonitorRecommendation> =

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationNotificationMode.test.ts

@@ -44,12 +44,13 @@ const OFFLINE_STATUS_ID: ObjectID = ObjectID.generate();
 const DEFAULT_STATUS_ID: ObjectID = ObjectID.generate();
 const INCIDENT_SEVERITY_ID: ObjectID = ObjectID.generate();
 const ALERT_SEVERITY_ID: ObjectID = ObjectID.generate();
+const RESOURCE_IDENTIFIER: string = ObjectID.generate().toString();
 
 function buildArgs(
   overrides?: Partial<MonitorRecommendationArgs>,
 ): MonitorRecommendationArgs {
   return {
-    resourceIdentifier: "prod-cluster-01",
+    resourceIdentifier: RESOURCE_IDENTIFIER,
     onlineMonitorStatusId: ONLINE_STATUS_ID,
     offlineMonitorStatusId: OFFLINE_STATUS_ID,
     defaultIncidentSeverityId: INCIDENT_SEVERITY_ID,
@@ -148,7 +149,7 @@ describe("MonitorRecommendationNotificationMode", () => {
     it("has recommendations to test at all", () => {
       // Guards every for-loop in this file against a vacuous pass.
       expect(ALL_RECOMMENDATIONS.length).toBeGreaterThan(0);
-      expect(ONE_PER_RESOURCE_TYPE.length).toBe(8);
+      expect(ONE_PER_RESOURCE_TYPE.length).toBe(9);
     });
 
     it("ships every unhealthy criteria with createIncidents AND createAlerts true, and both arrays populated", () => {

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationSeverityMapper.test.ts

@@ -545,7 +545,7 @@ describe("MonitorRecommendationSeverityMapper", () => {
 
     function buildArgs(): MonitorRecommendationArgs {
       return {
-        resourceIdentifier: "prod-cluster-01",
+        resourceIdentifier: ObjectID.generate().toString(),
         onlineMonitorStatusId: ObjectID.generate(),
         offlineMonitorStatusId: ObjectID.generate(),
         defaultIncidentSeverityId: TEMPLATE_INCIDENT_SEVERITY_ID,

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationUtil.test.ts

@@ -46,7 +46,7 @@ const DEFAULT_STATUS_ID: ObjectID = ObjectID.generate();
 const INCIDENT_SEVERITY_ID: ObjectID = ObjectID.generate();
 const ALERT_SEVERITY_ID: ObjectID = ObjectID.generate();
 
-const RESOURCE_IDENTIFIER: string = "prod-cluster-01";
+const RESOURCE_IDENTIFIER: string = ObjectID.generate().toString();
 
 function buildArgs(
   overrides?: Partial<MonitorRecommendationArgs>,
@@ -181,7 +181,7 @@ describe("MonitorRecommendationUtil", () => {
       }
     });
 
-    it("references at least one metric or formula per recommendation", () => {
+    it("references at least one metric, formula or telemetry query input per recommendation", () => {
       for (const recommendation of ALL_RECOMMENDATIONS) {
         const fingerprint: MonitorRecommendationFingerprint | undefined =
           MonitorRecommendationUtil.getFingerprintFromMonitorStep(
@@ -190,7 +190,8 @@ describe("MonitorRecommendationUtil", () => {
 
         expect(
           (fingerprint?.metricNames.length || 0) +
-            (fingerprint?.formulas.length || 0),
+            (fingerprint?.formulas.length || 0) +
+            (fingerprint?.configValues.length || 0),
         ).toBeGreaterThan(0);
       }
     });
@@ -636,6 +637,7 @@ describe("MonitorRecommendationUtil", () => {
         metricAliases: [],
         queryAttributes: [],
         criteriaFilters: [],
+        configValues: [],
       };
 
       const sorted: MonitorRecommendationFingerprint = {
@@ -646,6 +648,7 @@ describe("MonitorRecommendationUtil", () => {
         metricAliases: [],
         queryAttributes: [],
         criteriaFilters: [],
+        configValues: [],
       };
 
       expect(