@oneuptime/common 12.0.4 → 12.0.5

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

@@ -0,0 +1,401 @@
+import DomainMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/DomainMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import DomainLookupMethod from "../../../../../Types/Monitor/DomainMonitor/DomainLookupMethod";
+import DomainMonitorResponse from "../../../../../Types/Monitor/DomainMonitor/DomainMonitorResponse";
+import ProbeMonitorResponse from "../../../../../Types/Probe/ProbeMonitorResponse";
+import ObjectID from "../../../../../Types/ObjectID";
+
+function daysFromNow(days: number): string {
+  return new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString();
+}
+
+function buildDataToProcess(input: {
+  isOnline?: boolean;
+  isTimeout?: boolean;
+  failureCause?: string;
+  expiresDate?: string | undefined;
+  registrar?: string | undefined;
+  nameServers?: Array<string> | undefined;
+  domainStatus?: Array<string> | undefined;
+  lookupMethod?: DomainLookupMethod | undefined;
+}): ProbeMonitorResponse {
+  const domainResponse: DomainMonitorResponse = {
+    isOnline: input.isOnline ?? true,
+    responseTimeInMs: 42,
+    failureCause: input.failureCause ?? "",
+    domainName: "identity.digital",
+    expiresDate: input.expiresDate,
+    registrar: input.registrar,
+    nameServers: input.nameServers,
+    domainStatus: input.domainStatus,
+    lookupMethod: input.lookupMethod,
+  };
+
+  return {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    monitorStepId: ObjectID.generate(),
+    probeId: ObjectID.generate(),
+    failureCause: input.failureCause ?? "",
+    isOnline: input.isOnline ?? true,
+    isTimeout: input.isTimeout,
+    responseTimeInMs: 42,
+    domainResponse: domainResponse,
+    monitoredAt: new Date(),
+  };
+}
+
+async function evaluate(
+  dataToProcess: ProbeMonitorResponse,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return DomainMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess,
+    criteriaFilter,
+  });
+}
+
+describe("DomainMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  /*
+   * Regression for issue #3046. A domain whose TLD has no working WHOIS or
+   * RDAP service comes back with no expiry date, which makes every Domain*
+   * filter undecidable - so without an IsOnline check the monitor keeps its
+   * previous status and the failure is invisible.
+   */
+  describe("IsOnline", () => {
+    test("a failed lookup + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: false,
+          expiresDate: undefined,
+          failureCause:
+            "The WHOIS server for identity.digital answered without any registration data.",
+        }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("a failed lookup + True → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: false, expiresDate: undefined }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    test("a successful lookup + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true, expiresDate: daysFromNow(90) }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("a successful lookup + False → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("IsRequestTimeout", () => {
+    test("timed out + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: false, isTimeout: true }),
+        {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("did not time out + True → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true, isTimeout: false }),
+        {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    /*
+     * The probe has to send isTimeout: false explicitly on success. If it
+     * left the field unset this filter would be undecidable on every healthy
+     * check, and under FilterCondition.All the monitor could never go back
+     * online.
+     */
+    test("did not time out + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true, isTimeout: false }),
+        {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("an unset isTimeout is undecidable in both directions", async () => {
+      await expect(
+        evaluate(buildDataToProcess({ isOnline: true }), {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.False,
+          value: undefined,
+        }),
+      ).resolves.toBeNull();
+
+      await expect(
+        evaluate(buildDataToProcess({ isOnline: true }), {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.True,
+          value: undefined,
+        }),
+      ).resolves.toBeNull();
+    });
+  });
+
+  describe("DomainExpiresDaysIn", () => {
+    test("expiring in 10 days + LessThan 30 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ expiresDate: daysFromNow(10) }),
+        {
+          checkOn: CheckOn.DomainExpiresDaysIn,
+          filterType: FilterType.LessThan,
+          value: 30,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("expiring in 90 days + LessThan 30 → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ expiresDate: daysFromNow(90) }),
+        {
+          checkOn: CheckOn.DomainExpiresDaysIn,
+          filterType: FilterType.LessThan,
+          value: 30,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    // An unreadable registration cannot answer this - hence the IsOnline check.
+    test("no expiry date → undecidable", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: false, expiresDate: undefined }),
+        {
+          checkOn: CheckOn.DomainExpiresDaysIn,
+          filterType: FilterType.LessThan,
+          value: 30,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("DomainIsExpired", () => {
+    test("already expired + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ expiresDate: daysFromNow(-1) }),
+        {
+          checkOn: CheckOn.DomainIsExpired,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+      expect(result).toContain("Domain is expired");
+    });
+
+    test("not expired + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ expiresDate: daysFromNow(30) }),
+        {
+          checkOn: CheckOn.DomainIsExpired,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+      expect(result).toContain("Domain is not expired");
+    });
+
+    test("no expiry date → undecidable in both directions", async () => {
+      await expect(
+        evaluate(buildDataToProcess({ expiresDate: undefined }), {
+          checkOn: CheckOn.DomainIsExpired,
+          filterType: FilterType.True,
+          value: undefined,
+        }),
+      ).resolves.toBeNull();
+
+      await expect(
+        evaluate(buildDataToProcess({ expiresDate: undefined }), {
+          checkOn: CheckOn.DomainIsExpired,
+          filterType: FilterType.False,
+          value: undefined,
+        }),
+      ).resolves.toBeNull();
+    });
+  });
+
+  describe("DomainRegistrar", () => {
+    test("matches on equality", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ registrar: "Name.com, Inc." }),
+        {
+          checkOn: CheckOn.DomainRegistrar,
+          filterType: FilterType.EqualTo,
+          value: "Name.com, Inc.",
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("no registrar → undecidable", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ registrar: undefined }),
+        {
+          checkOn: CheckOn.DomainRegistrar,
+          filterType: FilterType.EqualTo,
+          value: "Name.com, Inc.",
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("DomainNameServer", () => {
+    test("matches any one of the name servers", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          nameServers: ["ns-525.awsdns-01.net", "ns-341.awsdns-42.com"],
+        }),
+        {
+          checkOn: CheckOn.DomainNameServer,
+          filterType: FilterType.Contains,
+          value: "awsdns-42",
+        },
+      );
+
+      expect(result).toBeTruthy();
+      expect(result).toContain("Domain name server: ");
+    });
+
+    test("no match → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ nameServers: ["ns1.example.com"] }),
+        {
+          checkOn: CheckOn.DomainNameServer,
+          filterType: FilterType.Contains,
+          value: "cloudflare",
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("DomainStatusCode", () => {
+    /*
+     * RDAP publishes "client transfer prohibited" and WHOIS publishes
+     * "clientTransferProhibited". The probe folds both to the EPP name so a
+     * criterion keeps matching when Auto switches protocol.
+     */
+    test("matches the EPP status name both lookup methods normalize to", async () => {
+      const viaRdap: string | null = await evaluate(
+        buildDataToProcess({
+          domainStatus: ["clientTransferProhibited"],
+          lookupMethod: DomainLookupMethod.RDAP,
+        }),
+        {
+          checkOn: CheckOn.DomainStatusCode,
+          filterType: FilterType.Contains,
+          value: "clientTransferProhibited",
+        },
+      );
+
+      const viaWhois: string | null = await evaluate(
+        buildDataToProcess({
+          domainStatus: ["clientTransferProhibited"],
+          lookupMethod: DomainLookupMethod.WHOIS,
+        }),
+        {
+          checkOn: CheckOn.DomainStatusCode,
+          filterType: FilterType.Contains,
+          value: "clientTransferProhibited",
+        },
+      );
+
+      expect(viaRdap).toBeTruthy();
+      expect(viaRdap).toContain("Domain status: ");
+      expect(viaWhois).toBeTruthy();
+    });
+
+    test("no statuses → undecidable", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ domainStatus: [] }),
+        {
+          checkOn: CheckOn.DomainStatusCode,
+          filterType: FilterType.Contains,
+          value: "clientHold",
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  test("an unrelated CheckOn is not claimed by this evaluator", async () => {
+    const result: string | null = await evaluate(buildDataToProcess({}), {
+      checkOn: CheckOn.ResponseTime,
+      filterType: FilterType.LessThan,
+      value: 1000,
+    });
+
+    expect(result).toBeNull();
+  });
+});

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

@@ -0,0 +1,243 @@
+import MetricType from "../../../../Models/DatabaseModels/MetricType";
+import GlobalConfigService from "../../../../Server/Services/GlobalConfigService";
+import MetricService from "../../../../Server/Services/MetricService";
+import MonitorMetricUtil from "../../../../Server/Utils/Monitor/MonitorMetricUtil";
+import TelemetryUtil from "../../../../Server/Utils/Telemetry/Telemetry";
+import Dictionary from "../../../../Types/Dictionary";
+import { JSONObject } from "../../../../Types/JSON";
+import MonitorMetricType from "../../../../Types/Monitor/MonitorMetricType";
+import PortMonitorTimings from "../../../../Types/Monitor/PortMonitor/PortMonitorTimings";
+import ObjectID from "../../../../Types/ObjectID";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const MONITOR_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const PROBE_ID: ObjectID = new ObjectID("33333333-3333-4333-8333-333333333333");
+
+function buildResponse(input: {
+  portTimings?: PortMonitorTimings;
+  responseTimeInMs?: number;
+  includeHttpTimings?: boolean;
+}): ProbeMonitorResponse {
+  return {
+    projectId: PROJECT_ID,
+    monitorId: MONITOR_ID,
+    monitorStepId: ObjectID.generate(),
+    probeId: PROBE_ID,
+    failureCause: "",
+    monitoredAt: new Date("2026-08-07T12:00:00.000Z"),
+    portTimings: input.portTimings,
+    responseTimeInMs: input.responseTimeInMs,
+    httpTimings: input.includeHttpTimings
+      ? { dnsLookupInMs: 11, tcpConnectInMs: 22 }
+      : undefined,
+  };
+}
+
+describe("MonitorMetricUtil Port connection phase persistence", () => {
+  let insertedRows: Array<JSONObject>;
+  let indexedMaps: Array<Dictionary<MetricType>>;
+
+  beforeEach(() => {
+    insertedRows = [];
+    indexedMaps = [];
+
+    jest
+      .spyOn(GlobalConfigService, "findOneBy")
+      .mockResolvedValue(null as never);
+    jest
+      .spyOn(MetricService, "insertJsonRows")
+      .mockImplementation(async (rows: Array<JSONObject>): Promise<void> => {
+        insertedRows.push(...rows);
+      });
+    jest
+      .spyOn(TelemetryUtil, "indexMetricNameServiceNameMap")
+      .mockImplementation(
+        async (data: {
+          projectId: ObjectID;
+          metricNameServiceNameMap: Dictionary<MetricType>;
+        }): Promise<void> => {
+          indexedMaps.push(data.metricNameServiceNameMap);
+        },
+      );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  async function save(response: ProbeMonitorResponse): Promise<void> {
+    await MonitorMetricUtil.saveMonitorMetrics({
+      monitorId: MONITOR_ID,
+      projectId: PROJECT_ID,
+      dataToProcess: response,
+      monitorName: "Database Port",
+      probeName: "London Probe",
+    });
+  }
+
+  function rowByName(name: MonitorMetricType): JSONObject | undefined {
+    return insertedRows.find((row: JSONObject) => {
+      return row["name"] === name;
+    });
+  }
+
+  test("persists DNS and TCP phases under Port-specific metric names", async () => {
+    await save(
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: 120,
+          tcpConnectInMs: 35,
+          totalConnectionInMs: 155,
+        },
+      }),
+    );
+
+    expect(insertedRows).toHaveLength(2);
+    expect(rowByName(MonitorMetricType.PortDnsLookupTime)?.["value"]).toBe(120);
+    expect(rowByName(MonitorMetricType.PortTcpConnectTime)?.["value"]).toBe(35);
+    expect(rowByName(MonitorMetricType.DnsLookupTime)).toBeUndefined();
+    expect(rowByName(MonitorMetricType.TcpConnectTime)).toBeUndefined();
+  });
+
+  test("adds monitor and probe identity to every phase row", async () => {
+    await save(
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: 10,
+          tcpConnectInMs: 20,
+          totalConnectionInMs: 30,
+        },
+      }),
+    );
+
+    for (const row of insertedRows) {
+      expect(row["primaryEntityId"]).toBe(MONITOR_ID.toString());
+      expect(row["projectId"]).toBe(PROJECT_ID.toString());
+      expect(row["attributes"]).toEqual(
+        expect.objectContaining({
+          monitorId: MONITOR_ID.toString(),
+          projectId: PROJECT_ID.toString(),
+          probeId: PROBE_ID.toString(),
+          monitorName: "Database Port",
+          probeName: "London Probe",
+        }),
+      );
+    }
+  });
+
+  test("registers both Port phase metric types with millisecond units", async () => {
+    await save(
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: 10,
+          tcpConnectInMs: 20,
+          totalConnectionInMs: 30,
+        },
+      }),
+    );
+
+    expect(indexedMaps).toHaveLength(1);
+    const metricMap: Dictionary<MetricType> = indexedMaps[0]!;
+    expect(metricMap[MonitorMetricType.PortDnsLookupTime]?.unit).toBe("ms");
+    expect(metricMap[MonitorMetricType.PortTcpConnectTime]?.unit).toBe("ms");
+    expect(
+      metricMap[MonitorMetricType.PortDnsLookupTime]?.description,
+    ).toContain("DNS lookup");
+    expect(
+      metricMap[MonitorMetricType.PortTcpConnectTime]?.description,
+    ).toContain("TCP connect");
+  });
+
+  test("keeps total connection time in the existing ResponseTime metric", async () => {
+    await save(
+      buildResponse({
+        responseTimeInMs: 155,
+        portTimings: {
+          dnsLookupInMs: 120,
+          tcpConnectInMs: 35,
+          totalConnectionInMs: 155,
+        },
+      }),
+    );
+
+    expect(rowByName(MonitorMetricType.ResponseTime)?.["value"]).toBe(155);
+    expect(
+      insertedRows.some((row: JSONObject) => {
+        return String(row["name"]).includes("port.total");
+      }),
+    ).toBe(false);
+  });
+
+  test("omits DNS for an IP literal while still persisting TCP", async () => {
+    await save(
+      buildResponse({
+        portTimings: { tcpConnectInMs: 18, totalConnectionInMs: 18 },
+      }),
+    );
+
+    expect(rowByName(MonitorMetricType.PortDnsLookupTime)).toBeUndefined();
+    expect(rowByName(MonitorMetricType.PortTcpConnectTime)?.["value"]).toBe(18);
+  });
+
+  test("persists legitimate zero-millisecond phases", async () => {
+    await save(
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: 0,
+          tcpConnectInMs: 0,
+          totalConnectionInMs: 0,
+        },
+      }),
+    );
+
+    expect(rowByName(MonitorMetricType.PortDnsLookupTime)?.["value"]).toBe(0);
+    expect(rowByName(MonitorMetricType.PortTcpConnectTime)?.["value"]).toBe(0);
+  });
+
+  test("skips absent and non-finite phase data", async () => {
+    await save(
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: Number.NaN,
+          tcpConnectInMs: Number.POSITIVE_INFINITY,
+          totalConnectionInMs: 100,
+        },
+      }),
+    );
+
+    expect(insertedRows).toEqual([]);
+    expect(MetricService.insertJsonRows).not.toHaveBeenCalled();
+    expect(indexedMaps).toEqual([{}]);
+  });
+
+  test("keeps HTTP and Port phase series distinct when both payloads are present", async () => {
+    await save(
+      buildResponse({
+        includeHttpTimings: true,
+        portTimings: {
+          dnsLookupInMs: 33,
+          tcpConnectInMs: 44,
+          totalConnectionInMs: 77,
+        },
+      }),
+    );
+
+    expect(rowByName(MonitorMetricType.DnsLookupTime)?.["value"]).toBe(11);
+    expect(rowByName(MonitorMetricType.TcpConnectTime)?.["value"]).toBe(22);
+    expect(rowByName(MonitorMetricType.PortDnsLookupTime)?.["value"]).toBe(33);
+    expect(rowByName(MonitorMetricType.PortTcpConnectTime)?.["value"]).toBe(44);
+  });
+});

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

@@ -463,6 +463,36 @@ describe("PasswordHash.verify — the schemes that came before", () => {
       }),
     ).resolves.toBe(false);
   });
+
+  test("a bare legacy hash with a stale salt still verifies during a rolling deployment", async () => {
+    /*
+     * An old pod knows nothing about the salt column. If it changes a
+     * password after a new pod has already put a salt on the row, it writes
+     * the original bare digest and leaves that salt behind. New code must try
+     * the bare legacy scheme after the salted legacy scheme fails, then the
+     * caller upgrades the row to scrypt.
+     */
+    const legacy: string = await HashedString.hashValue(
+      "rolling-password",
+      EncryptionSecret,
+    );
+
+    await expect(
+      PasswordHash.verify({
+        plainValue: "rolling-password",
+        storedValue: legacy,
+        salt: SALT,
+      }),
+    ).resolves.toBe(true);
+
+    await expect(
+      PasswordHash.verify({
+        plainValue: "wrong-password",
+        storedValue: legacy,
+        salt: SALT,
+      }),
+    ).resolves.toBe(false);
+  });
 });
 
 describe("PasswordHash.verify — malformed stored values", () => {