@oneuptime/common 14.0.9 → 14.0.10

package/Tests/Types/AutoRemediation/AiRemediationCommandPlanResourceCommand.test.ts

@@ -0,0 +1,305 @@
+import {
+  AI_COMMAND_STEP_TYPES,
+  AiRemediationCommand,
+  AiRemediationCommandPlan,
+  AiRemediationCommandPlanUtil,
+  AiRemediationCommandPolicyVerdict,
+} from "../../../Types/AutoRemediation/AiRemediationCommandPlan";
+import AiResourceType, {
+  AI_RESOURCE_TYPE_INFO,
+} from "../../../Types/ResourceAiAgent/AiResourceType";
+import { ResourceCommandTier } from "../../../Types/ResourceAiAgent/ResourceAiAccess";
+import { KubectlCommandTier } from "../../../Types/Kubernetes/KubernetesClusterAiAccess";
+import RunbookStepType from "../../../Types/Runbook/RunbookStepType";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Contract under test — ResourceCommand steps in a stored command plan.
+ *
+ * A ResourceCommand step runs through an infrastructure resource's own AI
+ * agent. Mirroring a Kubectl step aimed at the Kubernetes AI agent (whose
+ * runnerId is the KubernetesAiAgent row id and runnerNameSnapshot is
+ * "Kubernetes AI agent"), its runnerId holds the ResourceAiAgent row id and
+ * runnerNameSnapshot the type's agent display name ("Docker AI agent").
+ *
+ * parse() fails closed: the executor and the verifier act on what it
+ * returns, so a ResourceCommand step without a valid resourceType and
+ * resourceId, with any credential or cluster field, or with a Denied (or
+ * unknown) tier makes the WHOLE plan null. Plans stored before this step
+ * type existed must parse exactly as they did.
+ */
+
+const AGENT_ID: string = "11111111-1111-4111-8111-111111111111";
+const RESOURCE_ID: string = "22222222-2222-4222-8222-222222222222";
+
+function resourceStep(overrides: JSONObject = {}): JSONObject {
+  return {
+    sequence: 1,
+    stepType: RunbookStepType.ResourceCommand,
+    runnerId: AGENT_ID,
+    runnerNameSnapshot: "Docker AI agent",
+    resourceType: AiResourceType.DockerHost,
+    resourceId: RESOURCE_ID,
+    resourceNameSnapshot: "prod-web-1",
+    resourceCommandTier: ResourceCommandTier.SafeWrite,
+    command: "docker restart web",
+    timeoutInMs: 30000,
+    rationale: "web is wedged",
+    expectedEffect: "web serves again",
+    rollbackCommand: "docker start web",
+    policyVerdict: AiRemediationCommandPolicyVerdict.AutoApproved,
+    ...overrides,
+  };
+}
+
+function parseOne(step: JSONObject): AiRemediationCommand | null {
+  const plan: AiRemediationCommandPlan | null =
+    AiRemediationCommandPlanUtil.parse({ commands: [step] });
+
+  return plan ? plan.commands[0] || null : null;
+}
+
+describe("AI_COMMAND_STEP_TYPES admits ResourceCommand", () => {
+  test("ResourceCommand is an AI command step type", () => {
+    expect(AI_COMMAND_STEP_TYPES).toContain(RunbookStepType.ResourceCommand);
+  });
+});
+
+describe("AiRemediationCommandPlanUtil.parse — ResourceCommand steps", () => {
+  test("keeps the resource fields and the agent as the step's target", () => {
+    const command: AiRemediationCommand | null = parseOne(resourceStep());
+
+    expect(command).not.toBeNull();
+    expect(command?.stepType).toBe(RunbookStepType.ResourceCommand);
+    expect(command?.runnerId).toBe(AGENT_ID);
+    expect(command?.runnerNameSnapshot).toBe("Docker AI agent");
+    expect(command?.resourceType).toBe(AiResourceType.DockerHost);
+    expect(command?.resourceId).toBe(RESOURCE_ID);
+    expect(command?.resourceNameSnapshot).toBe("prod-web-1");
+    expect(command?.resourceCommandTier).toBe(ResourceCommandTier.SafeWrite);
+    expect(command?.command).toBe("docker restart web");
+    expect(command?.rollbackCommand).toBe("docker start web");
+    expect(command?.credentialId).toBeUndefined();
+    expect(command?.kubernetesClusterId).toBeUndefined();
+  });
+
+  test("survives a toJSON round trip unchanged", () => {
+    const plan: AiRemediationCommandPlan | null =
+      AiRemediationCommandPlanUtil.parse({ commands: [resourceStep()] });
+
+    expect(plan).not.toBeNull();
+    expect(
+      AiRemediationCommandPlanUtil.parse(
+        AiRemediationCommandPlanUtil.toJSON(plan!),
+      ),
+    ).toEqual(plan);
+  });
+
+  test.each(
+    Object.values(AiResourceType).map((type: AiResourceType) => {
+      return [type];
+    }),
+  )("accepts resourceType %s", (type: AiResourceType) => {
+    expect(parseOne(resourceStep({ resourceType: type }))?.resourceType).toBe(
+      type,
+    );
+  });
+
+  test.each([
+    ResourceCommandTier.Read,
+    ResourceCommandTier.SafeWrite,
+    ResourceCommandTier.RiskyWrite,
+  ])("accepts the %s tier", (tier: ResourceCommandTier) => {
+    expect(
+      parseOne(resourceStep({ resourceCommandTier: tier }))
+        ?.resourceCommandTier,
+    ).toBe(tier);
+  });
+
+  test("an absent tier is allowed (it is informational; execution re-evaluates)", () => {
+    const withoutTier: JSONObject = resourceStep();
+    delete withoutTier["resourceCommandTier"];
+
+    const command: AiRemediationCommand | null = parseOne(withoutTier);
+
+    expect(command).not.toBeNull();
+    expect(command?.resourceCommandTier).toBeUndefined();
+    expect(
+      parseOne(resourceStep({ resourceCommandTier: null })),
+    ).not.toBeNull();
+  });
+
+  test("defaults a missing runnerNameSnapshot to the type's agent name", () => {
+    const withoutName: JSONObject = resourceStep({
+      resourceType: AiResourceType.CephCluster,
+    });
+    delete withoutName["runnerNameSnapshot"];
+
+    expect(parseOne(withoutName)?.runnerNameSnapshot).toBe(
+      AI_RESOURCE_TYPE_INFO[AiResourceType.CephCluster].agentDisplayName,
+    );
+  });
+
+  describe("fails closed", () => {
+    test.each([
+      ["no resourceType", { resourceType: undefined }],
+      ["a null resourceType", { resourceType: null }],
+      ["an alias instead of the enum value", { resourceType: "docker" }],
+      ["a lowercased enum value", { resourceType: "dockerhost" }],
+      ["Kubernetes", { resourceType: "KubernetesCluster" }],
+      ["a numeric resourceType", { resourceType: 3 }],
+      ["no resourceId", { resourceId: undefined }],
+      ["a blank resourceId", { resourceId: "   " }],
+      ["a numeric resourceId", { resourceId: 42 }],
+      [
+        "a credentialId",
+        { credentialId: "33333333-3333-4333-8333-333333333333" },
+      ],
+      ["an empty credentialId", { credentialId: "" }],
+      ["a credentialNameSnapshot", { credentialNameSnapshot: "prod ssh key" }],
+      ["a resolved credential", { credential: { password: "hunter2" } }],
+      ["a cluster", { kubernetesClusterId: RESOURCE_ID }],
+      ["a Denied tier", { resourceCommandTier: ResourceCommandTier.Denied }],
+      ["an unknown tier", { resourceCommandTier: "Safe" }],
+      ["a lowercased tier", { resourceCommandTier: "safewrite" }],
+      ["a numeric tier", { resourceCommandTier: 1 }],
+      ["no runnerId (the agent)", { runnerId: "" }],
+      ["a Denied verdict", { policyVerdict: "Denied" }],
+    ])(
+      "%s makes the whole plan null",
+      (_label: string, overrides: JSONObject) => {
+        const step: JSONObject = resourceStep();
+
+        for (const [key, value] of Object.entries(overrides)) {
+          if (value === undefined) {
+            delete step[key];
+          } else {
+            step[key] = value;
+          }
+        }
+
+        expect(
+          AiRemediationCommandPlanUtil.parse({
+            commands: [
+              {
+                sequence: 1,
+                stepType: RunbookStepType.Bash,
+                runnerId: AGENT_ID,
+                command: "uptime",
+                policyVerdict: AiRemediationCommandPolicyVerdict.AutoApproved,
+              },
+              { ...step, sequence: 2 },
+            ],
+          }),
+        ).toBeNull();
+      },
+    );
+  });
+
+  test("resource fields on a non-resource step are ignored, not trusted", () => {
+    const plan: AiRemediationCommandPlan | null =
+      AiRemediationCommandPlanUtil.parse({
+        commands: [
+          {
+            sequence: 1,
+            stepType: RunbookStepType.Kubectl,
+            runnerId: AGENT_ID,
+            kubernetesClusterId: RESOURCE_ID,
+            kubectlTier: KubectlCommandTier.SafeWrite,
+            resourceType: AiResourceType.DockerHost,
+            resourceId: RESOURCE_ID,
+            resourceCommandTier: ResourceCommandTier.Denied,
+            command: "kubectl rollout restart deployment/web -n web",
+            policyVerdict: AiRemediationCommandPolicyVerdict.RequiresApproval,
+          },
+        ],
+      });
+
+    expect(plan).not.toBeNull();
+    expect(plan?.commands[0]).not.toHaveProperty("resourceType");
+    expect(plan?.commands[0]).not.toHaveProperty("resourceId");
+    expect(plan?.commands[0]).not.toHaveProperty("resourceCommandTier");
+  });
+});
+
+describe("plans stored before ResourceCommand parse exactly as before", () => {
+  /*
+   * The shape of every key parse produces for an old step — no resource
+   * keys added, and the Runner default name kept.
+   */
+  test("a Bash, an SSH and a Kubectl step keep their exact parsed shape", () => {
+    const plan: AiRemediationCommandPlan | null =
+      AiRemediationCommandPlanUtil.parse({
+        commands: [
+          {
+            sequence: 1,
+            stepType: RunbookStepType.Bash,
+            runnerId: AGENT_ID,
+            command: "systemctl restart nginx",
+            timeoutInMs: 30000,
+            rationale: "r",
+            expectedEffect: "e",
+            policyVerdict: AiRemediationCommandPolicyVerdict.AutoApproved,
+          },
+          {
+            sequence: 2,
+            stepType: RunbookStepType.SSH,
+            runnerId: AGENT_ID,
+            runnerNameSnapshot: "office-runner",
+            credentialId: "44444444-4444-4444-8444-444444444444",
+            credentialNameSnapshot: "db ssh",
+            command: "uptime",
+            timeoutInMs: 30000,
+            rationale: "r",
+            expectedEffect: "e",
+            policyVerdict: AiRemediationCommandPolicyVerdict.RequiresApproval,
+          },
+          {
+            sequence: 3,
+            stepType: RunbookStepType.Kubectl,
+            runnerId: AGENT_ID,
+            runnerNameSnapshot: "Kubernetes AI agent",
+            kubernetesClusterId: RESOURCE_ID,
+            kubernetesClusterNameSnapshot: "prod-us",
+            kubectlTier: KubectlCommandTier.SafeWrite,
+            command: "kubectl rollout restart deployment/web -n web",
+            timeoutInMs: 30000,
+            rationale: "r",
+            expectedEffect: "e",
+            policyVerdict: AiRemediationCommandPolicyVerdict.RequiresApproval,
+          },
+        ],
+      });
+
+    expect(plan).not.toBeNull();
+
+    const expectedKeys: Array<string> = [
+      "command",
+      "credentialId",
+      "credentialNameSnapshot",
+      "execution",
+      "expectedEffect",
+      "kubectlTier",
+      "kubernetesClusterId",
+      "kubernetesClusterNameSnapshot",
+      "policyVerdict",
+      "rationale",
+      "rollbackCommand",
+      "rollbackExecution",
+      "runnerId",
+      "runnerNameSnapshot",
+      "sequence",
+      "stepType",
+      "timeoutInMs",
+      "wasAutoExecuted",
+    ];
+
+    for (const command of plan!.commands) {
+      expect(Object.keys(command).sort()).toEqual(expectedKeys);
+    }
+
+    expect(plan!.commands[0]?.runnerNameSnapshot).toBe("Runner");
+    expect(plan!.commands[2]?.kubectlTier).toBe(KubectlCommandTier.SafeWrite);
+  });
+});

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

@@ -19,7 +19,11 @@ 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";
+import {
+  RumAlertTemplate,
+  getAllRumAlertTemplates,
+  getRumAlertTemplates,
+} from "../../../../Types/Monitor/RumAlertTemplates";
 import { getAllVMwareAlertTemplates } from "../../../../Types/Monitor/VMwareAlertTemplates";
 import {
   getAllServiceAlertTemplates,
@@ -69,16 +73,18 @@ 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.
+   * Everything the module can ever produce. For the resource types whose set
+   * is a constant this is also what the page shows; for Service it is the
+   * union across every runtime, for Database across every engine, and for RUM
+   * it includes the session replay budget alerts.
    */
   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.
+   * smaller for Service (the language-agnostic subset), Database (nothing)
+   * and RUM (everything but the budget alerts).
    */
   contextFreeTemplateCount: number;
   identifierFieldName:
@@ -163,7 +169,13 @@ const MODULE_EXPECTATIONS: Array<ModuleExpectation> = [
       MonitorType.Exceptions,
     ],
     templateCount: getAllRumAlertTemplates().length,
-    contextFreeTemplateCount: getAllRumAlertTemplates().length,
+    /*
+     * Everything but the session replay budget alerts, which wait until the
+     * application is known to record replays. `getRumAlertTemplates(undefined)`
+     * is the module's own answer to "what applies to an application we know
+     * nothing about".
+     */
+    contextFreeTemplateCount: getRumAlertTemplates(undefined).length,
     identifierFieldName: "rumApplicationId",
   },
   {
@@ -525,12 +537,13 @@ describe("MonitorRecommendationCatalog", () => {
   });
 
   /*
-   * 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.
+   * Services were the first resource type whose recommendation set is not a
+   * constant (databases and RUM applications have suites of their own below).
+   * Everything here is about the seam between "what applies to this resource"
+   * and "what this catalog can ever produce" — the same question for every
+   * resource type whose set is a constant, and a different one for these, 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;
@@ -603,9 +616,16 @@ describe("MonitorRecommendationCatalog", () => {
       for (const resourceType of Object.values(
         MonitorRecommendationResourceType,
       )) {
+        /*
+         * The three resource types whose set is NOT a constant, each with a
+         * suite of its own below: a service by runtime, a database by engine,
+         * and a RUM application by whether it records session replays (its
+         * budget alerts).
+         */
         if (
           resourceType === MonitorRecommendationResourceType.Service ||
-          resourceType === MonitorRecommendationResourceType.DatabaseServer
+          resourceType === MonitorRecommendationResourceType.DatabaseServer ||
+          resourceType === MonitorRecommendationResourceType.RumApplication
         ) {
           continue;
         }
@@ -617,9 +637,19 @@ describe("MonitorRecommendationCatalog", () => {
             },
           );
 
+        /*
+         * Every fact any resource type reads, set to the value that moves its
+         * own list the most, so a constant set that started reading one of
+         * them would change here.
+         */
         const withContext: Array<string> =
           MonitorRecommendationCatalog.getRecommendations(resourceType, {
             serviceLanguage: "java",
+            databaseEngine: "postgresql",
+            databaseEngineMetricsReported: true,
+            sessionReplayEnabled: true,
+            sessionReplayHasRecorded: true,
+            sessionReplayMonthlyBudgetInGB: 10,
           }).map((recommendation: MonitorRecommendation) => {
             return recommendation.recommendationId;
           });
@@ -906,4 +936,238 @@ describe("MonitorRecommendationCatalog", () => {
       expect(new Set(categories).size).toBe(categories.length);
     });
   });
+
+  /*
+   * RUM applications: the third context-dependent resource type. Every
+   * application is offered the same web vital and error recommendations, but
+   * the session replay budget alerts only once the application records
+   * replays (and, for the monthly pair, has a monthly budget) - the sweep
+   * writes nothing for any other application, so each would be a monitor
+   * that can never fire. The page's side-menu badge counts from the same
+   * answer, so a wrong one inflates the badge on every RUM application.
+   */
+  describe("RUM application recommendations", () => {
+    const FULL_REPLAY_CONTEXT: MonitorRecommendationContext = {
+      sessionReplayEnabled: true,
+      sessionReplayHasRecorded: true,
+      sessionReplayMonthlyBudgetInGB: 10,
+    };
+
+    const BUDGET_TEMPLATE_IDS: Array<string> = [
+      "rum-session-replay-daily-budget-nearly-spent",
+      "rum-session-replay-daily-budget-spent",
+      "rum-session-replay-monthly-budget-nearly-spent",
+      "rum-session-replay-monthly-budget-spent",
+    ];
+
+    function rumRecommendationIds(
+      context?: MonitorRecommendationContext | undefined,
+    ): Array<string> {
+      return MonitorRecommendationCatalog.getRecommendations(
+        MonitorRecommendationResourceType.RumApplication,
+        context,
+      ).map((recommendation: MonitorRecommendation) => {
+        return recommendation.recommendationId;
+      });
+    }
+
+    function idsOf(templates: Array<RumAlertTemplate>): Array<string> {
+      return templates.map((template: RumAlertTemplate) => {
+        return buildRecommendationId(
+          MonitorRecommendationResourceType.RumApplication,
+          template.id,
+        );
+      });
+    }
+
+    it("offers the original seven when nothing is known about the application", () => {
+      const contextFree: Array<string> = rumRecommendationIds();
+
+      expect(contextFree).toHaveLength(7);
+      expect(contextFree).toEqual(idsOf(getRumAlertTemplates(undefined)));
+      expect(rumRecommendationIds({})).toEqual(contextFree);
+
+      for (const templateId of BUDGET_TEMPLATE_IDS) {
+        expect(contextFree).not.toContain(
+          buildRecommendationId(
+            MonitorRecommendationResourceType.RumApplication,
+            templateId,
+          ),
+        );
+      }
+    });
+
+    it("offers all eleven, in the module's order, to an application that records and has a budget", () => {
+      const offered: Array<string> = rumRecommendationIds(FULL_REPLAY_CONTEXT);
+
+      expect(offered).toHaveLength(11);
+      expect(offered).toEqual(idsOf(getAllRumAlertTemplates()));
+    });
+
+    /*
+     * The adapter re-assembles the module's context field by field, so a
+     * field it forgot to forward would read as "not known" - withholding the
+     * alerts on every page while every other test stays green. One case per
+     * field: each moves the count, so each must have arrived.
+     */
+    it("forwards every replay fact to the module", () => {
+      expect(
+        rumRecommendationIds({
+          sessionReplayEnabled: true,
+          sessionReplayHasRecorded: true,
+        }),
+      ).toEqual(
+        idsOf(
+          getRumAlertTemplates({
+            sessionReplayEnabled: true,
+            sessionReplayHasRecorded: true,
+          }),
+        ),
+      );
+      expect(
+        rumRecommendationIds({
+          sessionReplayEnabled: true,
+          sessionReplayHasRecorded: true,
+        }),
+      ).toHaveLength(9);
+      expect(
+        rumRecommendationIds({
+          ...FULL_REPLAY_CONTEXT,
+          sessionReplayEnabled: false,
+        }),
+      ).toHaveLength(7);
+      expect(
+        rumRecommendationIds({
+          ...FULL_REPLAY_CONTEXT,
+          sessionReplayHasRecorded: false,
+        }),
+      ).toHaveLength(7);
+      expect(
+        rumRecommendationIds({
+          ...FULL_REPLAY_CONTEXT,
+          sessionReplayMonthlyBudgetInGB: 0,
+        }),
+      ).toHaveLength(9);
+    });
+
+    it("stays exhaustive, and resolves every budget recommendation by id with no context", () => {
+      /*
+       * The path a dismissal takes: the row stores a recommendation id and
+       * nothing about the application, so lookup has to work without one.
+       */
+      const all: Array<MonitorRecommendation> =
+        MonitorRecommendationCatalog.getAllPossibleRecommendations(
+          MonitorRecommendationResourceType.RumApplication,
+        );
+
+      expect(all).toHaveLength(11);
+      expect(all.length).toBe(getAllRumAlertTemplates().length);
+
+      for (const templateId of BUDGET_TEMPLATE_IDS) {
+        const recommendation: MonitorRecommendation | undefined =
+          MonitorRecommendationCatalog.getRecommendationById(
+            buildRecommendationId(
+              MonitorRecommendationResourceType.RumApplication,
+              templateId,
+            ),
+          );
+
+        expect(recommendation).toBeDefined();
+        expect(recommendation?.templateId).toBe(templateId);
+        expect(recommendation?.resourceType).toBe(
+          MonitorRecommendationResourceType.RumApplication,
+        );
+        expect(recommendation?.monitorType).toBe(MonitorType.Metrics);
+        expect(recommendation?.category).toBe("Session Replay");
+      }
+    });
+
+    it("lists Session Replay last, and only once the budget alerts are offered", () => {
+      const contextFreeCategories: Array<string> =
+        MonitorRecommendationCatalog.getCategories(
+          MonitorRecommendationResourceType.RumApplication,
+        );
+      const fullCategories: Array<string> =
+        MonitorRecommendationCatalog.getCategories(
+          MonitorRecommendationResourceType.RumApplication,
+          FULL_REPLAY_CONTEXT,
+        );
+
+      expect(contextFreeCategories).toEqual(["Core Web Vitals", "Errors"]);
+      expect(fullCategories).toEqual([
+        ...contextFreeCategories,
+        "Session Replay",
+      ]);
+      expect(fullCategories[fullCategories.length - 1]).toBe("Session Replay");
+    });
+
+    it("scopes every budget recommendation's step to the application id", () => {
+      const rumApplicationId: string = ObjectID.generate().toString();
+
+      const budgetRecommendations: Array<MonitorRecommendation> =
+        MonitorRecommendationCatalog.getRecommendations(
+          MonitorRecommendationResourceType.RumApplication,
+          FULL_REPLAY_CONTEXT,
+        ).filter((item: MonitorRecommendation) => {
+          return item.category === "Session Replay";
+        });
+
+      // Or the loop below would pass having checked nothing.
+      expect(
+        budgetRecommendations.map((recommendation: MonitorRecommendation) => {
+          return recommendation.templateId;
+        }),
+      ).toEqual(BUDGET_TEMPLATE_IDS);
+
+      for (const recommendation of budgetRecommendations) {
+        const step: MonitorStep = recommendation.getMonitorStep({
+          resourceIdentifier: rumApplicationId,
+          onlineMonitorStatusId: ObjectID.generate(),
+          offlineMonitorStatusId: ObjectID.generate(),
+          defaultIncidentSeverityId: ObjectID.generate(),
+          defaultAlertSeverityId: ObjectID.generate(),
+          monitorName: "Storefront",
+        });
+
+        expect(
+          step.data?.metricMonitor?.telemetryServiceIds?.map((id: ObjectID) => {
+            return id.toString();
+          }),
+        ).toEqual([rumApplicationId]);
+      }
+    });
+
+    it("keeps the three context-dependent resource types independent", () => {
+      // Replay facts change nothing for a service or a database...
+      expect(
+        MonitorRecommendationCatalog.getRecommendations(
+          MonitorRecommendationResourceType.Service,
+          FULL_REPLAY_CONTEXT,
+        ).map((recommendation: MonitorRecommendation) => {
+          return recommendation.recommendationId;
+        }),
+      ).toEqual(
+        MonitorRecommendationCatalog.getRecommendations(
+          MonitorRecommendationResourceType.Service,
+        ).map((recommendation: MonitorRecommendation) => {
+          return recommendation.recommendationId;
+        }),
+      );
+      expect(
+        MonitorRecommendationCatalog.getRecommendations(
+          MonitorRecommendationResourceType.DatabaseServer,
+          FULL_REPLAY_CONTEXT,
+        ),
+      ).toEqual([]);
+
+      // ...and a runtime or an engine changes nothing for a RUM application.
+      expect(
+        rumRecommendationIds({
+          serviceLanguage: "java",
+          databaseEngine: "postgresql",
+          databaseEngineMetricsReported: true,
+        }),
+      ).toEqual(rumRecommendationIds());
+    });
+  });
 });