@oneuptime/common 13.0.0 → 13.0.1

package/Tests/Server/Utils/EmailRollup/EmailRollupWriter.test.ts

@@ -14,6 +14,7 @@ import logger from "../../../../Server/Utils/Logger";
 import CreateBy from "../../../../Server/Types/Database/CreateBy";
 import UserNotificationEmailRollupItem from "../../../../Models/DatabaseModels/UserNotificationEmailRollupItem";
 import Dictionary from "../../../../Types/Dictionary";
+import ColumnLength from "../../../../Types/Database/ColumnLength";
 import Email from "../../../../Types/Email";
 import { EmailEnvelope } from "../../../../Types/Email/EmailMessage";
 import EmailTemplateType from "../../../../Types/Email/EmailTemplateType";
@@ -107,6 +108,11 @@ interface CapturedPreferenceRead {
   projectId: ObjectID;
 }
 
+interface SeveritySnapshotCase {
+  severityVar: string;
+  eventType: NotificationSettingEventType;
+}
+
 function buildEnvelope(overrides: Partial<EmailEnvelope> = {}): EmailEnvelope {
   return {
     subject: "Incident created: Checkout is down",
@@ -535,6 +541,185 @@ describe("EmailRollupWriter.sendOrRollup", () => {
    * -----------------------------------------------------------------------
    */
 
+  describe("severity and state snapshots", () => {
+    const families: Array<{
+      severityVar: string;
+      eventTypes: Array<NotificationSettingEventType>;
+    }> = [
+      {
+        severityVar: "alertSeverity",
+        eventTypes: [
+          NotificationSettingEventType.SEND_ALERT_CREATED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_NOTE_POSTED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_OWNER_ADDED_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_REMINDER_OWNER_NOTIFICATION,
+        ],
+      },
+      {
+        severityVar: "incidentSeverity",
+        eventTypes: [
+          NotificationSettingEventType.SEND_INCIDENT_CREATED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_STATE_CHANGED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_NOTE_POSTED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_OWNER_ADDED_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_MEMBER_ADDED_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_REMINDER_OWNER_NOTIFICATION,
+        ],
+      },
+      {
+        severityVar: "episodeSeverity",
+        eventTypes: [
+          NotificationSettingEventType.SEND_ALERT_EPISODE_CREATED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_EPISODE_STATE_CHANGED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_EPISODE_NOTE_POSTED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_EPISODE_OWNER_ADDED_NOTIFICATION,
+          NotificationSettingEventType.SEND_ALERT_ADDED_TO_EPISODE_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_EPISODE_CREATED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_EPISODE_STATE_CHANGED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_EPISODE_NOTE_POSTED_OWNER_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_EPISODE_OWNER_ADDED_NOTIFICATION,
+          NotificationSettingEventType.SEND_INCIDENT_ADDED_TO_EPISODE_OWNER_NOTIFICATION,
+        ],
+      },
+    ];
+
+    const snapshotCases: Array<SeveritySnapshotCase> = [];
+
+    for (const family of families) {
+      for (const eventType of family.eventTypes) {
+        snapshotCases.push({
+          severityVar: family.severityVar,
+          eventType: eventType,
+        });
+      }
+    }
+
+    test.each(snapshotCases)(
+      "snapshots the matching severity and state for $eventType",
+      async (snapshotCase: SeveritySnapshotCase) => {
+        recentCount(BURST_THRESHOLD);
+        const vars: Dictionary<string | JSONObject> = {
+          alertSeverity: "Alert severity",
+          incidentSeverity: "Incident severity",
+          episodeSeverity: "Episode severity",
+          currentState: " Awaiting review ",
+        };
+        vars[snapshotCase.severityVar] = " Customer-defined priority ";
+
+        await EmailRollupWriter.sendOrRollup(
+          sendData({
+            eventType: snapshotCase.eventType,
+            emailEnvelope: buildEnvelope({ vars: vars }),
+          }),
+        );
+
+        expect(writtenItem().severity).toBe("Customer-defined priority");
+        expect(writtenItem().currentState).toBe("Awaiting review");
+        expect(writtenItem().sentAt).toBeUndefined();
+        expect(sendMail).not.toHaveBeenCalled();
+      },
+    );
+
+    test.each([undefined, null, "", " \t\n ", 42, true, { name: "Critical" }])(
+      "ignores missing or non-text metadata %p without disrupting deferral",
+      async (value: unknown) => {
+        recentCount(BURST_THRESHOLD);
+        await EmailRollupWriter.sendOrRollup(
+          sendData({
+            emailEnvelope: buildEnvelope({
+              vars: {
+                incidentSeverity: value,
+                currentState: value,
+              } as Dictionary<string | JSONObject>,
+            }),
+          }),
+        );
+
+        expect(writtenItem().severity).toBeUndefined();
+        expect(writtenItem().currentState).toBeUndefined();
+        expect(sendMail).not.toHaveBeenCalled();
+        expect(loggerError).not.toHaveBeenCalled();
+      },
+    );
+
+    test.each(["incidentSeverity", "currentState"])(
+      "keeps %s even when the other label is absent",
+      async (name: string) => {
+        await EmailRollupWriter.sendOrRollup(
+          sendData({
+            emailEnvelope: buildEnvelope({ vars: { [name]: "Custom label" } }),
+          }),
+        );
+
+        expect(writtenItem().severity).toBe(
+          name === "incidentSeverity" ? "Custom label" : undefined,
+        );
+        expect(writtenItem().currentState).toBe(
+          name === "currentState" ? "Custom label" : undefined,
+        );
+      },
+    );
+
+    test("bounds both labels to their database column length", async () => {
+      recentCount(BURST_THRESHOLD);
+      await EmailRollupWriter.sendOrRollup(
+        sendData({
+          emailEnvelope: buildEnvelope({
+            vars: {
+              incidentSeverity: ` ${"S".repeat(5000)} `,
+              currentState: ` ${"T".repeat(5000)} `,
+            },
+          }),
+        }),
+      );
+
+      expect(writtenItem().severity).toBe("S".repeat(ColumnLength.ShortText));
+      expect(writtenItem().currentState).toBe(
+        "T".repeat(ColumnLength.ShortText),
+      );
+      expect(sendMail).not.toHaveBeenCalled();
+      expect(loggerError).not.toHaveBeenCalled();
+    });
+
+    test("leaves the original immediate email and its custom labels unchanged", async () => {
+      const vars: Dictionary<string | JSONObject> = {
+        incidentSeverity: " Critical <P1> & {{custom}} ",
+        currentState: " Awaiting review ",
+      };
+      const original: Dictionary<string | JSONObject> = { ...vars };
+      await EmailRollupWriter.sendOrRollup(
+        sendData({ emailEnvelope: buildEnvelope({ vars: vars }) }),
+      );
+
+      expect(vars).toEqual(original);
+      expect((sendMail.mock.calls[0]?.[0] as EmailEnvelope).vars).toEqual(
+        original,
+      );
+      expect(writtenItem().severity).toBe("Critical <P1> & {{custom}}");
+      expect(writtenItem().currentState).toBe("Awaiting review");
+    });
+
+    test("does not attach incidental alert metadata to other notification categories", async () => {
+      await EmailRollupWriter.sendOrRollup(
+        sendData({
+          eventType: MONITOR_EVENT,
+          emailEnvelope: buildEnvelope({
+            vars: {
+              alertSeverity: "Critical",
+              incidentSeverity: "Critical",
+              episodeSeverity: "Critical",
+              currentState: "Resolved",
+            },
+          }),
+        }),
+      );
+
+      expect(writtenItem().severity).toBeUndefined();
+      expect(writtenItem().currentState).toBeUndefined();
+    });
+  });
+
   describe("the stored subject", () => {
     test("a 5,000 character subject is truncated to the column length rather than throwing", async () => {
       const longSubject: string = "x".repeat(5000);

package/Tests/Server/Utils/LogRedaction.test.ts

@@ -61,6 +61,9 @@ describe("isSensitiveLogKey", () => {
       "parameters",
       "parameterValues",
       "bindParameters",
+      "codeVerifier",
+      "code_verifier",
+      "CODE-VERIFIER",
     ]) {
       expect(isSensitiveLogKey(key)).toBe(true);
     }
@@ -439,3 +442,33 @@ describe("redactLogValue - safety properties", () => {
     expect(output).toContain("[Truncated]");
   });
 });
+
+describe("mobile passkey PKCE exchange redaction", () => {
+  it("redacts both the authorization code and the verifier in a structured body", () => {
+    const output: string = serialize({
+      code: SENTINEL,
+      codeVerifier: SENTINEL,
+      state: "public-correlation-value",
+    });
+    expect(output).not.toContain(SENTINEL);
+    expect(JSON.parse(output)).toEqual({
+      code: REDACTED,
+      codeVerifier: REDACTED,
+      state: "public-correlation-value",
+    });
+  });
+
+  it.each(["codeVerifier", "code_verifier", "code-verifier"])(
+    "redacts %s after a request body or URL has already been stringified",
+    (key: string) => {
+      for (const value of [
+        JSON.stringify({ [key]: SENTINEL }),
+        `${key}=${SENTINEL}&state=public`,
+        `https://example.com/identity/mobile-passkey-exchange?${key}=${SENTINEL}`,
+      ]) {
+        expect(redactLogString(value)).not.toContain(SENTINEL);
+        expect(redactLogString(value)).toContain(REDACTED);
+      }
+    },
+  );
+});

package/Tests/Server/Utils/Monitor/CapturedMetricAttributeUtil.test.ts

@@ -151,13 +151,14 @@ describe("CapturedMetricAttributeUtil", () => {
           "k8s.cluster.name": "prod",
           "iot.fleet.name": "fleet-a",
           "proxmox.cluster.name": "pve",
+          "vmware.vcenter.name": "vcsa",
           "ceph.cluster.name": "ceph",
           "docker.swarm.cluster.name": "swarm",
           keep: "yes",
         });
 
       expect(result.attributes).toEqual({ keep: "yes" });
-      expect(result.droppedReservedKeys).toHaveLength(7);
+      expect(result.droppedReservedKeys).toHaveLength(8);
     });
 
     test("records numbers and booleans as text instead of dropping them", () => {

package/Tests/Server/Utils/Monitor/Criteria/TelemetryStepMetricAlias.test.ts

@@ -23,6 +23,7 @@ import { MonitorStepHostMonitorUtil } from "../../../../../Types/Monitor/Monitor
 import { MonitorStepKubernetesMonitorUtil } from "../../../../../Types/Monitor/MonitorStepKubernetesMonitor";
 import { MonitorStepPodmanMonitorUtil } from "../../../../../Types/Monitor/MonitorStepPodmanMonitor";
 import { MonitorStepProxmoxMonitorUtil } from "../../../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import { MonitorStepVMwareMonitorUtil } from "../../../../../Types/Monitor/MonitorStepVMwareMonitor";
 import RollingTime from "../../../../../Types/RollingTime/RollingTime";
 import ObjectID from "../../../../../Types/ObjectID";
 
@@ -316,6 +317,15 @@ describe("MetricMonitorCriteria — other telemetry step shapes", () => {
         };
       },
     },
+    {
+      name: "vmwareMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.vmwareMonitor = {
+          ...MonitorStepVMwareMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
     {
       name: "cephMonitor",
       assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {

package/Tests/Server/Utils/Monitor/MonitorAlertResourceLinking.test.ts

@@ -24,6 +24,7 @@ import NetworkDeviceOwnerUserService from "../../../../Server/Services/NetworkDe
 import PodmanHostService from "../../../../Server/Services/PodmanHostService";
 import ProxmoxClusterService from "../../../../Server/Services/ProxmoxClusterService";
 import ServiceService from "../../../../Server/Services/ServiceService";
+import VMwareVCenterService from "../../../../Server/Services/VMwareVCenterService";
 import ProjectScopedReferenceValidator from "../../../../Server/Utils/Database/ProjectScopedReferenceValidator";
 import MonitorAlert from "../../../../Server/Utils/Monitor/MonitorAlert";
 import MonitorResourceContextUtil from "../../../../Server/Utils/Monitor/MonitorResourceContext";
@@ -135,7 +136,7 @@ function idsOn(
 }
 
 /*
- * The nine-relation shape MonitorResourceContext resolves from the
+ * The ten-relation shape MonitorResourceContext resolves from the
  * monitor's own step config. Tests stub the util and hand back one of
  * these, spreading over it to name only the relations under test.
  */
@@ -147,6 +148,7 @@ function emptyResourceContext(): SeriesResolvedResourceIds {
     kubernetesClusterIds: [],
     serviceIds: [],
     proxmoxClusterIds: [],
+    vmwareVCenterIds: [],
     cephClusterIds: [],
     dockerSwarmClusterIds: [],
     iotFleetIds: [],
@@ -167,6 +169,7 @@ describe("Alerts link the resources their series identifies", () => {
   let dockerHostRows: Array<{ _id: string }> = [];
   let podmanHostRows: Array<{ _id: string }> = [];
   let proxmoxClusterRows: Array<{ _id: string }> = [];
+  let vmwareVCenterRows: Array<{ _id: string }> = [];
   let cephClusterRows: Array<{ _id: string }> = [];
   let dockerSwarmClusterRows: Array<{ _id: string }> = [];
   let iotFleetRows: Array<{ _id: string }> = [];
@@ -183,6 +186,7 @@ describe("Alerts link the resources their series identifies", () => {
     dockerHostRows = [];
     podmanHostRows = [];
     proxmoxClusterRows = [];
+    vmwareVCenterRows = [];
     cephClusterRows = [];
     dockerSwarmClusterRows = [];
     iotFleetRows = [];
@@ -232,6 +236,9 @@ describe("Alerts link the resources their series identifies", () => {
     jest.spyOn(ProxmoxClusterService, "findBy").mockImplementation(async () => {
       return proxmoxClusterRows as never;
     });
+    jest.spyOn(VMwareVCenterService, "findBy").mockImplementation(async () => {
+      return vmwareVCenterRows as never;
+    });
     jest.spyOn(CephClusterService, "findBy").mockImplementation(async () => {
       return cephClusterRows as never;
     });
@@ -325,6 +332,7 @@ describe("Alerts link the resources their series identifies", () => {
     dockerHostRows = [{ _id: "docker-1" }];
     podmanHostRows = [{ _id: "podman-1" }];
     proxmoxClusterRows = [{ _id: "pve-1" }];
+    vmwareVCenterRows = [{ _id: "vcsa-1" }];
     cephClusterRows = [{ _id: "ceph-1" }];
     dockerSwarmClusterRows = [{ _id: "swarm-1" }];
     iotFleetRows = [{ _id: "fleet-1" }];
@@ -344,6 +352,7 @@ describe("Alerts link the resources their series identifies", () => {
             "oneuptime.docker.host.name": "docker-box",
             "oneuptime.podman.host.name": "podman-box",
             "proxmox.cluster.name": "pve",
+            "vmware.vcenter.name": "vcsa",
             "ceph.cluster.name": "ceph",
             "docker.swarm.cluster.name": "swarm",
             "iot.fleet.name": "fleet",
@@ -362,6 +371,7 @@ describe("Alerts link the resources their series identifies", () => {
     expect(idsOn(alert.dockerHosts)).toEqual(["docker-1"]);
     expect(idsOn(alert.podmanHosts)).toEqual(["podman-1"]);
     expect(idsOn(alert.proxmoxClusters)).toEqual(["pve-1"]);
+    expect(idsOn(alert.vmwareVCenters)).toEqual(["vcsa-1"]);
     expect(idsOn(alert.cephClusters)).toEqual(["ceph-1"]);
     expect(idsOn(alert.dockerSwarmClusters)).toEqual(["swarm-1"]);
     expect(idsOn(alert.iotFleets)).toEqual(["fleet-1"]);
@@ -586,6 +596,61 @@ describe("Alerts link the resources their series identifies", () => {
     ]);
   });
 
+  it("merges the monitor's step-config vCenter with the one the series names", async () => {
+    /*
+     * VMware twin of the Proxmox merge above: a user-built monitor
+     * grouped by `vmware.vcenter.name` names one vCenter through its
+     * labels while the step's vcenterIdentifier resolves to another.
+     */
+    vmwareVCenterRows = [{ _id: "vcsa-from-label" }];
+    resourceContext = {
+      ...emptyResourceContext(),
+      vmwareVCenterIds: ["vcsa-from-step-config"],
+    };
+
+    await MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Host CPU utilization is above 90%",
+      autoResolveCriteriaInstanceIdAlertIdsDictionary: NO_AUTO_RESOLVE,
+      matchesPerSeries: [
+        series({ "resource.vmware.vcenter.name": "vcsa" }, "fp-1"),
+      ],
+      props: {},
+    });
+
+    expect(idsOn(createdAlerts[0]!.vmwareVCenters).sort()).toEqual([
+      "vcsa-from-label",
+      "vcsa-from-step-config",
+    ]);
+  });
+
+  it("still attaches the step-config vCenter to an ungrouped alert", async () => {
+    /*
+     * The shipped VMware templates group by the vSphere object's own
+     * attribute (`resource.vcenter.host.name`), never by the vCenter,
+     * so the vCenter link on their alerts comes ONLY from the step
+     * config path. This is the path the vCenter Alerts tab depends on.
+     */
+    resourceContext = {
+      ...emptyResourceContext(),
+      vmwareVCenterIds: ["vcsa-1"],
+    };
+
+    await MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Datastore capacity is above 90%",
+      autoResolveCriteriaInstanceIdAlertIdsDictionary: NO_AUTO_RESOLVE,
+      props: {},
+    });
+
+    expect(idsOn(createdAlerts[0]!.vmwareVCenters)).toEqual(["vcsa-1"]);
+    expect(VMwareVCenterService.findBy).not.toHaveBeenCalled();
+  });
+
   it("still attaches the step-config cluster to an ungrouped alert", async () => {
     resourceContext = {
       ...emptyResourceContext(),