@oneuptime/common 12.0.12 → 12.0.14

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

@@ -3,6 +3,7 @@ import MonitorRecommendationCatalog, {
 } from "../../../../Types/Monitor/Recommendation/MonitorRecommendationCatalog";
 import {
   MonitorRecommendation,
+  MonitorRecommendationContext,
   MonitorRecommendationResourceType,
   buildRecommendationId,
 } from "../../../../Types/Monitor/Recommendation/MonitorRecommendationTypes";
@@ -17,9 +18,14 @@ import { getAllKubernetesAlertTemplates } from "../../../../Types/Monitor/Kubern
 import { getAllPodmanAlertTemplates } from "../../../../Types/Monitor/PodmanAlertTemplates";
 import { getAllProxmoxAlertTemplates } from "../../../../Types/Monitor/ProxmoxAlertTemplates";
 import { getAllRumAlertTemplates } from "../../../../Types/Monitor/RumAlertTemplates";
+import {
+  getAllServiceAlertTemplates,
+  getLanguagesWithServiceAlertTemplates,
+  getServiceAlertTemplates,
+} from "../../../../Types/Monitor/ServiceAlertTemplates";
 
 /*
- * The catalog is the seam between eight independently-maintained alert-template
+ * The catalog is the seam between ten independently-maintained alert-template
  * modules and one Recommendations UI. Everything it can silently get wrong is
  * a wiring mistake that produces a page that looks fine and creates broken or
  * duplicated monitors:
@@ -43,12 +49,25 @@ import { getAllRumAlertTemplates } from "../../../../Types/Monitor/RumAlertTempl
 interface ModuleExpectation {
   resourceType: MonitorRecommendationResourceType;
   monitorTypes: Array<MonitorType>;
+  /*
+   * Everything the module can ever produce. For nine of the ten this is also
+   * what the page shows; for Service it is the union across every runtime.
+   */
   templateCount: number;
+  /*
+   * What `getRecommendations(resourceType)` returns with NO context — what a
+   * caller that knows nothing about the specific resource is offered. Equal to
+   * `templateCount` for every resource type whose set is a constant, and
+   * smaller for Service, where knowing nothing means the language-agnostic
+   * subset.
+   */
+  contextFreeTemplateCount: number;
   identifierFieldName:
     | "clusterIdentifier"
     | "hostIdentifier"
     | "fleetIdentifier"
-    | "rumApplicationId";
+    | "rumApplicationId"
+    | "serviceId";
 }
 
 const MODULE_EXPECTATIONS: Array<ModuleExpectation> = [
@@ -56,48 +75,56 @@ const MODULE_EXPECTATIONS: Array<ModuleExpectation> = [
     resourceType: MonitorRecommendationResourceType.Kubernetes,
     monitorTypes: [MonitorType.Kubernetes],
     templateCount: getAllKubernetesAlertTemplates().length,
+    contextFreeTemplateCount: getAllKubernetesAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Host,
     monitorTypes: [MonitorType.Host],
     templateCount: getAllHostAlertTemplates().length,
+    contextFreeTemplateCount: getAllHostAlertTemplates().length,
     identifierFieldName: "hostIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Docker,
     monitorTypes: [MonitorType.Docker],
     templateCount: getAllDockerAlertTemplates().length,
+    contextFreeTemplateCount: getAllDockerAlertTemplates().length,
     identifierFieldName: "hostIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.DockerSwarm,
     monitorTypes: [MonitorType.DockerSwarm],
     templateCount: getAllDockerSwarmAlertTemplates().length,
+    contextFreeTemplateCount: getAllDockerSwarmAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Podman,
     monitorTypes: [MonitorType.Podman],
     templateCount: getAllPodmanAlertTemplates().length,
+    contextFreeTemplateCount: getAllPodmanAlertTemplates().length,
     identifierFieldName: "hostIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Proxmox,
     monitorTypes: [MonitorType.Proxmox],
     templateCount: getAllProxmoxAlertTemplates().length,
+    contextFreeTemplateCount: getAllProxmoxAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.Ceph,
     monitorTypes: [MonitorType.Ceph],
     templateCount: getAllCephAlertTemplates().length,
+    contextFreeTemplateCount: getAllCephAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
   {
     resourceType: MonitorRecommendationResourceType.IoTDevice,
     monitorTypes: [MonitorType.IoTDevice],
     templateCount: getAllIoTAlertTemplates().length,
+    contextFreeTemplateCount: getAllIoTAlertTemplates().length,
     identifierFieldName: "fleetIdentifier",
   },
   {
@@ -108,8 +135,26 @@ const MODULE_EXPECTATIONS: Array<ModuleExpectation> = [
       MonitorType.Exceptions,
     ],
     templateCount: getAllRumAlertTemplates().length,
+    contextFreeTemplateCount: getAllRumAlertTemplates().length,
     identifierFieldName: "rumApplicationId",
   },
+  {
+    resourceType: MonitorRecommendationResourceType.Service,
+    monitorTypes: [
+      MonitorType.Metrics,
+      MonitorType.Traces,
+      MonitorType.Exceptions,
+    ],
+    templateCount: getAllServiceAlertTemplates().length,
+    /*
+     * The only row where these two differ, and the reason the field exists.
+     * `getServiceAlertTemplates(null)` is the module's own answer to "what
+     * applies to a service whose runtime is unknown", so this stays correct
+     * when a template moves between the agnostic and language-specific sets.
+     */
+    contextFreeTemplateCount: getServiceAlertTemplates(null).length,
+    identifierFieldName: "serviceId",
+  },
 ];
 
 describe("MonitorRecommendationCatalog", () => {
@@ -143,7 +188,17 @@ describe("MonitorRecommendationCatalog", () => {
       /*
        * A dropped `.map` or a filtered adapter would show up here as a count
        * mismatch rather than as a quietly shorter list in the UI.
+       *
+       * Two counts, because the two questions are different and only one of
+       * them is context-free: `getRecommendations` with no context answers
+       * "what applies to a resource we know nothing about", while
+       * `getAllRecommendations` has to stay exhaustive or every invariant
+       * downstream of it silently stops covering the language-specific half of
+       * the service catalog.
        */
+      const allRecommendations: Array<MonitorRecommendation> =
+        MonitorRecommendationCatalog.getAllRecommendations();
+
       for (const expectation of MODULE_EXPECTATIONS) {
         const recommendations: Array<MonitorRecommendation> =
           MonitorRecommendationCatalog.getRecommendations(
@@ -151,7 +206,16 @@ describe("MonitorRecommendationCatalog", () => {
           );
 
         expect(expectation.templateCount).toBeGreaterThan(0);
-        expect(recommendations.length).toBe(expectation.templateCount);
+        expect(expectation.contextFreeTemplateCount).toBeGreaterThan(0);
+        expect(recommendations.length).toBe(
+          expectation.contextFreeTemplateCount,
+        );
+
+        expect(
+          allRecommendations.filter((recommendation: MonitorRecommendation) => {
+            return recommendation.resourceType === expectation.resourceType;
+          }).length,
+        ).toBe(expectation.templateCount);
       }
     });
 
@@ -195,8 +259,8 @@ describe("MonitorRecommendationCatalog", () => {
     it("canary: raw templateIds happen to be globally unique today", () => {
       /*
        * Every module self-prefixes (`host-high-cpu`, `docker-high-cpu`,
-       * `podman-high-cpu`), so no two of the 76 collide right now. That is a
-       * convention across eight independently maintained files, not a
+       * `podman-high-cpu`), so no two of them collide right now. That is a
+       * convention across ten independently maintained files, not a
        * contract — each module only promises uniqueness within itself.
        *
        * This test is a canary, NOT a requirement the registry depends on. If
@@ -396,4 +460,197 @@ describe("MonitorRecommendationCatalog", () => {
       ).toEqual([]);
     });
   });
+
+  /*
+   * Services are the only resource type whose recommendation set is not a
+   * constant. Everything below is about the seam between "what applies to this
+   * resource" and "what this catalog can ever produce" — the two are the same
+   * question for nine resource types and different for the tenth, and the
+   * failure mode of conflating them is a page that offers JVM heap monitors to
+   * a Go service.
+   */
+  describe("context-aware recommendations", () => {
+    const AGNOSTIC_COUNT: number = getServiceAlertTemplates(null).length;
+
+    function serviceRecommendationIds(
+      context?: MonitorRecommendationContext | undefined,
+    ): Array<string> {
+      return MonitorRecommendationCatalog.getRecommendations(
+        MonitorRecommendationResourceType.Service,
+        context,
+      ).map((recommendation: MonitorRecommendation) => {
+        return recommendation.recommendationId;
+      });
+    }
+
+    it("treats no context, an empty context and a null language alike", () => {
+      /*
+       * `detectServiceLanguage` returns null while an absent field is
+       * undefined, so both reach this API in practice. They mean the same
+       * thing and must not diverge — a null narrowing to some default language
+       * would be the worst possible reading of "we could not tell".
+       */
+      const noContext: Array<string> = serviceRecommendationIds();
+
+      expect(noContext.length).toBe(AGNOSTIC_COUNT);
+      expect(serviceRecommendationIds({})).toEqual(noContext);
+      expect(serviceRecommendationIds({ serviceLanguage: null })).toEqual(
+        noContext,
+      );
+      expect(serviceRecommendationIds({ serviceLanguage: undefined })).toEqual(
+        noContext,
+      );
+    });
+
+    it("adds a runtime's own recommendations on top of the agnostic set", () => {
+      const agnostic: Array<string> = serviceRecommendationIds();
+      const forJava: Array<string> = serviceRecommendationIds({
+        serviceLanguage: "java",
+      });
+
+      expect(forJava.length).toBeGreaterThan(agnostic.length);
+
+      for (const recommendationId of agnostic) {
+        expect(forJava).toContain(recommendationId);
+      }
+    });
+
+    it("never offers one runtime's recommendations to another", () => {
+      const forJava: Array<string> = serviceRecommendationIds({
+        serviceLanguage: "java",
+      });
+      const forGo: Array<string> = serviceRecommendationIds({
+        serviceLanguage: "go",
+      });
+
+      const javaOnly: Array<string> = forJava.filter(
+        (recommendationId: string) => {
+          return !serviceRecommendationIds().includes(recommendationId);
+        },
+      );
+
+      expect(javaOnly.length).toBeGreaterThan(0);
+
+      for (const recommendationId of javaOnly) {
+        expect(forGo).not.toContain(recommendationId);
+      }
+    });
+
+    it("is inert for every resource type whose set is a constant", () => {
+      for (const resourceType of Object.values(
+        MonitorRecommendationResourceType,
+      )) {
+        if (resourceType === MonitorRecommendationResourceType.Service) {
+          continue;
+        }
+
+        const withoutContext: Array<string> =
+          MonitorRecommendationCatalog.getRecommendations(resourceType).map(
+            (recommendation: MonitorRecommendation) => {
+              return recommendation.recommendationId;
+            },
+          );
+
+        const withContext: Array<string> =
+          MonitorRecommendationCatalog.getRecommendations(resourceType, {
+            serviceLanguage: "java",
+          }).map((recommendation: MonitorRecommendation) => {
+            return recommendation.recommendationId;
+          });
+
+        expect(withContext).toEqual(withoutContext);
+      }
+    });
+
+    it("keeps getAllRecommendations exhaustive", () => {
+      /*
+       * The registry-wide invariants — unique ids, distinct fingerprints,
+       * a mappable severity — all run over this. If it narrowed to the
+       * context-free subset, the language-specific templates would be the ones
+       * left unchecked, which is exactly the half most likely to collide.
+       */
+      const serviceRecommendations: Array<MonitorRecommendation> =
+        MonitorRecommendationCatalog.getAllRecommendations().filter(
+          (recommendation: MonitorRecommendation) => {
+            return (
+              recommendation.resourceType ===
+              MonitorRecommendationResourceType.Service
+            );
+          },
+        );
+
+      expect(serviceRecommendations.length).toBe(
+        getAllServiceAlertTemplates().length,
+      );
+      expect(serviceRecommendations.length).toBeGreaterThan(AGNOSTIC_COUNT);
+    });
+
+    it("resolves a language-specific recommendation by id, with no context", () => {
+      /*
+       * The path a dismissal takes: the row stores a recommendation id and
+       * nothing about the language, so lookup has to work without one.
+       */
+      for (const template of getAllServiceAlertTemplates()) {
+        const recommendationId: string = buildRecommendationId(
+          MonitorRecommendationResourceType.Service,
+          template.id,
+        );
+
+        expect(
+          MonitorRecommendationCatalog.getRecommendationById(recommendationId),
+        ).toBeDefined();
+      }
+    });
+
+    it("lists the agnostic categories first, whatever the runtime", () => {
+      const agnosticCategories: Array<string> =
+        MonitorRecommendationCatalog.getCategories(
+          MonitorRecommendationResourceType.Service,
+        );
+
+      expect(agnosticCategories.length).toBeGreaterThan(0);
+
+      for (const language of getLanguagesWithServiceAlertTemplates()) {
+        const categories: Array<string> =
+          MonitorRecommendationCatalog.getCategories(
+            MonitorRecommendationResourceType.Service,
+            { serviceLanguage: language },
+          );
+
+        expect(categories.slice(0, agnosticCategories.length)).toEqual(
+          agnosticCategories,
+        );
+        expect(categories.length).toBeGreaterThan(agnosticCategories.length);
+      }
+    });
+
+    it("carries the service monitor types the coverage query needs", () => {
+      /*
+       * The page queries existing monitors by these types. A missing one means
+       * monitors of that type are never considered, so every recommendation it
+       * covers renders as still-to-do and accepting it creates a duplicate.
+       */
+      const definition: MonitorRecommendationResourceTypeDefinition =
+        MonitorRecommendationCatalog.getResourceTypeDefinition(
+          MonitorRecommendationResourceType.Service,
+        )!;
+
+      const usedMonitorTypes: Set<MonitorType> = new Set<MonitorType>(
+        MonitorRecommendationCatalog.getAllRecommendations()
+          .filter((recommendation: MonitorRecommendation) => {
+            return (
+              recommendation.resourceType ===
+              MonitorRecommendationResourceType.Service
+            );
+          })
+          .map((recommendation: MonitorRecommendation) => {
+            return recommendation.monitorType;
+          }),
+      );
+
+      for (const monitorType of usedMonitorTypes) {
+        expect(definition.monitorTypes).toContain(monitorType);
+      }
+    });
+  });
 });

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

@@ -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(9);
+    expect(RESOURCE_TYPE_DEFINITIONS.length).toBe(10);
 
     for (const definition of RESOURCE_TYPE_DEFINITIONS) {
       const recommendations: Array<MonitorRecommendation> =

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

@@ -149,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(9);
+      expect(ONE_PER_RESOURCE_TYPE.length).toBe(10);
     });
 
     it("ships every unhealthy criteria with createIncidents AND createAlerts true, and both arrays populated", () => {