@oneuptime/common 12.0.13 → 12.0.15

package/Tests/Utils/NetworkDiscovery/UnclaimedScanDiagnosis.test.ts

@@ -0,0 +1,214 @@
+import {
+  MAX_SCAN_STATUS_MESSAGE_LENGTH,
+  UNCLAIMED_PENDING_MINUTES,
+  UnclaimedScanProbeState,
+  buildUnclaimedScanDiagnosis,
+} from "../../../Utils/NetworkDiscovery/UnclaimedScanDiagnosis";
+import OneUptimeDate from "../../../Types/Date";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The sentence a stuck discovery scan gets to say for itself.
+ *
+ * A scan leaves "Pending" only when a probe asks for it. When no probe ever
+ * does, nothing times out and nothing fails — the row simply never moves, and
+ * before this existed the product said nothing at all about it. OneUptime
+ * issue #3287 is that silence: four scans submitted over an hour, all
+ * "Pending", an em-dash where the result goes, and no way to tell a scan
+ * queued a second ago from one no probe will ever pick up.
+ *
+ * So these tests are about the WORDS, not a state machine: whether an operator
+ * reading the row learns which of the two very different problems they have,
+ * and whether the sentence survives the varchar(500) column it is written to.
+ */
+
+const disconnectedProbe: UnclaimedScanProbeState = {
+  probeName: "Datacentre Probe",
+  isProbeConnected: false,
+  lastAliveAt: OneUptimeDate.getSomeHoursAgo(6),
+};
+
+const connectedProbe: UnclaimedScanProbeState = {
+  probeName: "Datacentre Probe",
+  isProbeConnected: true,
+  lastAliveAt: OneUptimeDate.getCurrentDate(),
+};
+
+describe("buildUnclaimedScanDiagnosis — the probe is not connected", () => {
+  test("names the probe the operator chose", () => {
+    expect(buildUnclaimedScanDiagnosis(disconnectedProbe)).toContain(
+      'Probe "Datacentre Probe"',
+    );
+  });
+
+  test("says the probe is not connected, which is the actual fault", () => {
+    expect(buildUnclaimedScanDiagnosis(disconnectedProbe)).toContain(
+      "is not connected to OneUptime",
+    );
+  });
+
+  /*
+   * "Last seen 6 hours ago" is the difference between "my probe just
+   * restarted" and "that probe has been gone since the upgrade".
+   */
+  test("says when the probe was last seen", () => {
+    expect(buildUnclaimedScanDiagnosis(disconnectedProbe)).toContain(
+      "It was last seen",
+    );
+  });
+
+  test("a probe that has never connected says exactly that, not 'last seen never'", () => {
+    const message: string = buildUnclaimedScanDiagnosis({
+      probeName: "Brand New Probe",
+      isProbeConnected: false,
+      lastAliveAt: null,
+    });
+
+    expect(message).toContain("It has never connected.");
+    expect(message).not.toContain("last seen");
+  });
+
+  test("a missing lastAlive is treated the same as never connecting", () => {
+    expect(
+      buildUnclaimedScanDiagnosis({
+        isProbeConnected: false,
+      }),
+    ).toContain("It has never connected.");
+  });
+
+  /*
+   * The scan is annotated, not failed, so the operator needs to know they do
+   * not have to re-create it.
+   */
+  test("promises the scan still runs once the probe returns", () => {
+    expect(buildUnclaimedScanDiagnosis(disconnectedProbe)).toContain(
+      "as soon as the probe reconnects",
+    );
+  });
+});
+
+describe("buildUnclaimedScanDiagnosis — the probe IS connected", () => {
+  /*
+   * A completely different problem with a completely different fix: the probe
+   * is running and authenticating, but its discovery job is not claiming
+   * scans — an old image, a wedged sweep, or a probe that can reach the
+   * heartbeat route but not the probe-ingest one.
+   */
+  test("does not blame the connection", () => {
+    const message: string = buildUnclaimedScanDiagnosis(connectedProbe);
+
+    expect(message).toContain("is connected but has not picked this scan up");
+    expect(message).not.toContain("is not connected");
+  });
+
+  test("names the two things worth checking", () => {
+    const message: string = buildUnclaimedScanDiagnosis(connectedProbe);
+
+    expect(message).toContain("version that supports");
+    expect(message).toContain("probe-ingest");
+  });
+
+  test("quotes the threshold it actually waited for", () => {
+    expect(buildUnclaimedScanDiagnosis(connectedProbe)).toContain(
+      `${UNCLAIMED_PENDING_MINUTES} minutes`,
+    );
+  });
+
+  test("the two branches are genuinely different sentences", () => {
+    expect(buildUnclaimedScanDiagnosis(connectedProbe)).not.toBe(
+      buildUnclaimedScanDiagnosis(disconnectedProbe),
+    );
+  });
+});
+
+describe("buildUnclaimedScanDiagnosis — a probe with no readable name", () => {
+  test("falls back to a phrase that still reads as a sentence", () => {
+    const message: string = buildUnclaimedScanDiagnosis({
+      isProbeConnected: false,
+      lastAliveAt: null,
+    });
+
+    expect(message).toContain("The assigned probe is not connected");
+    expect(message).not.toContain('Probe ""');
+  });
+
+  test("an empty-string name is treated as no name", () => {
+    expect(
+      buildUnclaimedScanDiagnosis({
+        probeName: "",
+        isProbeConnected: true,
+      }),
+    ).toContain("The assigned probe");
+  });
+});
+
+describe("buildUnclaimedScanDiagnosis — it has to fit the column", () => {
+  /*
+   * statusMessage is a varchar(500) and this message is written through the
+   * full update pipeline, which does NOT clamp. An over-long value throws, and
+   * the diagnosis is lost precisely when it is most needed.
+   */
+  test("the column ceiling is the one the model declares", () => {
+    expect(MAX_SCAN_STATUS_MESSAGE_LENGTH).toBe(500);
+  });
+
+  test("every message fits, for both branches", () => {
+    for (const probeState of [disconnectedProbe, connectedProbe]) {
+      expect(
+        buildUnclaimedScanDiagnosis(probeState).length,
+      ).toBeLessThanOrEqual(MAX_SCAN_STATUS_MESSAGE_LENGTH);
+    }
+  });
+
+  /*
+   * A probe name is a ShortText column, so 100 characters is the real worst
+   * case. Feeding well past it proves the truncation is what bounds the
+   * message rather than the caller's good manners.
+   */
+  test("an absurdly long probe name cannot overflow the column", () => {
+    const longName: string = "N".repeat(400);
+
+    for (const isProbeConnected of [true, false]) {
+      const message: string = buildUnclaimedScanDiagnosis({
+        probeName: longName,
+        isProbeConnected: isProbeConnected,
+        lastAliveAt: OneUptimeDate.getSomeHoursAgo(200),
+      });
+
+      expect(message.length).toBeLessThanOrEqual(
+        MAX_SCAN_STATUS_MESSAGE_LENGTH,
+      );
+    }
+  });
+
+  test("a long name is cut with an ellipsis rather than silently dropped", () => {
+    const message: string = buildUnclaimedScanDiagnosis({
+      probeName: "N".repeat(400),
+      isProbeConnected: false,
+    });
+
+    expect(message).toContain("NNN");
+    expect(message).toContain("…");
+  });
+
+  test("a name that fits is left exactly as the operator typed it", () => {
+    expect(
+      buildUnclaimedScanDiagnosis({
+        probeName: "core-sw-probe-01",
+        isProbeConnected: false,
+      }),
+    ).toContain('Probe "core-sw-probe-01"');
+  });
+});
+
+describe("the grace period", () => {
+  /*
+   * The probe polls every minute, so this is a count of consecutive failed
+   * polls. Too short and a probe redeploy annotates every queued scan; too
+   * long and the operator has given up before the product says anything.
+   */
+  test("is long enough to ride out a probe restart and short enough to be useful", () => {
+    expect(UNCLAIMED_PENDING_MINUTES).toBeGreaterThanOrEqual(5);
+    expect(UNCLAIMED_PENDING_MINUTES).toBeLessThanOrEqual(60);
+  });
+});

package/Tests/Utils/Rum/UrlScrubberSegments.test.ts

@@ -0,0 +1,362 @@
+import { describe, expect, it } from "@jest/globals";
+import UrlScrubber from "../../../Utils/Rum/UrlScrubber";
+
+/*
+ * The parent UrlScrubber.test.ts drives the whole pipeline through the
+ * public scrub()/getScrubbedPathname() facade. This suite pins the two
+ * segment-level primitives directly — scrubPath() and scrubQuery() — so
+ * that the branch behaviour each one owns (every redaction pattern and its
+ * length boundary, the decode-before-match step, the empty/"/" short
+ * circuits, and the allowlist rules) is exercised in isolation rather than
+ * only as an emergent property of a full URL round-trip.
+ *
+ * Everything here is a pure function of its arguments: no network, no clock,
+ * no randomness. scrubQuery takes a plain URLSearchParams built inline.
+ */
+
+const REDACTED: string = "[redacted]";
+
+describe("UrlScrubber segment primitives", () => {
+  describe("scrubPath", () => {
+    describe("empty and boundary inputs", () => {
+      it("normalises an empty path to a single slash", () => {
+        /*
+         * The `pathname || "/"` fallback: an empty string is not passed
+         * through as-is, it is turned into the root path.
+         */
+        expect(UrlScrubber.scrubPath("")).toBe("/");
+      });
+
+      it("returns the root path unchanged", () => {
+        expect(UrlScrubber.scrubPath("/")).toBe("/");
+      });
+
+      it("keeps a path whose segments are all ordinary route words", () => {
+        expect(UrlScrubber.scrubPath("/blog/how-we-scaled-clickhouse")).toBe(
+          "/blog/how-we-scaled-clickhouse",
+        );
+      });
+
+      it("preserves the leading empty segment produced by the leading slash", () => {
+        /*
+         * "/orders/2".split("/") is ["", "orders", "2"]; the empty first
+         * element must survive the map so the result stays absolute.
+         */
+        const scrubbed: string = UrlScrubber.scrubPath("/orders/2");
+
+        expect(scrubbed).toBe("/orders/2");
+        expect(scrubbed.startsWith("/")).toBe(true);
+      });
+
+      it("preserves a trailing slash and collapsed empty segments", () => {
+        expect(UrlScrubber.scrubPath("/a//b/")).toBe("/a//b/");
+      });
+
+      it("handles a path that is a single identifier segment", () => {
+        expect(
+          UrlScrubber.scrubPath("/3f1a9c7e-5b2d-4801-96a3-c9e7b1d5028f"),
+        ).toBe(`/${REDACTED}`);
+      });
+    });
+
+    describe("uuid segments", () => {
+      it("redacts a canonical lowercase uuid while keeping the route shape", () => {
+        expect(
+          UrlScrubber.scrubPath(
+            "/orders/3f1a9c7e-5b2d-4801-96a3-c9e7b1d5028f/items",
+          ),
+        ).toBe(`/orders/${REDACTED}/items`);
+      });
+
+      it("redacts a uuid case-insensitively", () => {
+        expect(
+          UrlScrubber.scrubPath("/orders/3F1A9C7E-5B2D-4801-96A3-C9E7B1D5028F"),
+        ).toBe(`/orders/${REDACTED}`);
+      });
+
+      it("does not treat a uuid-shaped-but-wrong-length string as a uuid", () => {
+        /*
+         * A truncated uuid (30 chars): it fails the anchored uuid pattern
+         * and, being under the 32-char opaque-token threshold, escapes that
+         * rule too, so it survives as ordinary route structure.
+         */
+        const almost: string = "3f1a9c7e-5b2d-4801-96a3-c9e7b1";
+
+        expect(almost.length).toBeLessThan(32);
+        expect(UrlScrubber.scrubPath(`/x/${almost}`)).toBe(`/x/${almost}`);
+      });
+    });
+
+    describe("object id segments", () => {
+      it("redacts a 24-character Mongo/BSON object id", () => {
+        expect(UrlScrubber.scrubPath("/users/6512f3a9b7c4d2e108f5a3b9")).toBe(
+          `/users/${REDACTED}`,
+        );
+      });
+
+      it("keeps a 23-character hex string, one short of an object id", () => {
+        const shortHex: string = "6512f3a9b7c4d2e108f5a3b";
+
+        expect(UrlScrubber.scrubPath(`/users/${shortHex}`)).toBe(
+          `/users/${shortHex}`,
+        );
+      });
+    });
+
+    describe("email segments", () => {
+      it("redacts a plain email segment", () => {
+        expect(UrlScrubber.scrubPath("/u/someone@example.com/profile")).toBe(
+          `/u/${REDACTED}/profile`,
+        );
+      });
+
+      it("redacts a percent-encoded email by decoding before matching", () => {
+        /*
+         * name%40example.com decodes to name@example.com; the decode step
+         * is what lets the email pattern see it.
+         */
+        const scrubbed: string = UrlScrubber.scrubPath(
+          "/u/someone%40example.com",
+        );
+
+        expect(scrubbed).toBe(`/u/${REDACTED}`);
+        expect(scrubbed).not.toContain("%40");
+        expect(scrubbed).not.toContain("someone");
+      });
+
+      it("keeps a segment that merely contains an at-sign but is not an address", () => {
+        /*
+         * A handle like "@acme" has no domain part, so the anchored email
+         * pattern rejects it and it is treated as route structure.
+         */
+        expect(UrlScrubber.scrubPath("/team/@acme")).toBe("/team/@acme");
+      });
+    });
+
+    describe("long digit-run segments", () => {
+      it("redacts a run of 9 or more digits (card / phone / SSN shaped)", () => {
+        expect(UrlScrubber.scrubPath("/account/4111111111111111")).toBe(
+          `/account/${REDACTED}`,
+        );
+      });
+
+      it("redacts at the 9-digit boundary", () => {
+        expect(UrlScrubber.scrubPath("/n/123456789")).toBe(`/n/${REDACTED}`);
+      });
+
+      it("keeps an 8-digit run just under the boundary", () => {
+        expect(UrlScrubber.scrubPath("/n/12345678")).toBe("/n/12345678");
+      });
+
+      it("keeps a short numeric id, which is route structure not PII", () => {
+        expect(UrlScrubber.scrubPath("/page/2")).toBe("/page/2");
+      });
+    });
+
+    describe("opaque token segments", () => {
+      it("redacts a 32-or-longer high-entropy token", () => {
+        expect(
+          UrlScrubber.scrubPath(
+            "/s/aVeryLongOpaqueSessionTokenValue1234567890",
+          ),
+        ).toBe(`/s/${REDACTED}`);
+      });
+
+      it("redacts exactly at the 32-character boundary", () => {
+        const token: string = "a".repeat(32);
+
+        expect(UrlScrubber.scrubPath(`/s/${token}`)).toBe(`/s/${REDACTED}`);
+      });
+
+      it("keeps a 31-character string just under the boundary", () => {
+        const slug: string = "a".repeat(31);
+
+        expect(UrlScrubber.scrubPath(`/s/${slug}`)).toBe(`/s/${slug}`);
+      });
+
+      it("keeps a long slug that carries a dot outside the token charset", () => {
+        /*
+         * The opaque-token charset is [A-Za-z0-9_-]; a dot disqualifies the
+         * whole segment even when it is well over 32 characters, so a
+         * dotted asset name survives.
+         */
+        const dotted: string = "this-is-a-fairly-long-report-name.2024.final";
+
+        expect(UrlScrubber.scrubPath(`/files/${dotted}`)).toBe(
+          `/files/${dotted}`,
+        );
+      });
+    });
+
+    describe("decode fallback and structure preservation", () => {
+      it("never throws and leaves a malformed percent-escape segment intact", () => {
+        /*
+         * decodeURIComponent("%E0%A4%A") throws; the catch falls back to
+         * matching the raw segment, which matches nothing, so the segment
+         * is returned exactly as given rather than crashing the mapper.
+         */
+        const malformed: string = "%E0%A4%A";
+
+        let scrubbed: string = "";
+
+        expect((): void => {
+          scrubbed = UrlScrubber.scrubPath(`/x/${malformed}`);
+        }).not.toThrow();
+
+        expect(scrubbed).toBe(`/x/${malformed}`);
+      });
+
+      it("returns the raw (still-encoded) form for a non-PII encoded segment", () => {
+        /*
+         * A kept segment is returned in its original encoded form, not the
+         * decoded one: "caf%C3%A9" decodes to "café", matches no pattern,
+         * and comes back byte-for-byte as it went in.
+         */
+        expect(UrlScrubber.scrubPath("/menu/caf%C3%A9")).toBe(
+          "/menu/caf%C3%A9",
+        );
+      });
+
+      it("redacts only the identifier segments in a mixed path", () => {
+        const mixed: string =
+          "/org/acme/users/6512f3a9b7c4d2e108f5a3b9/orders/2/token/" +
+          "aVeryLongOpaqueSessionTokenValue1234567890";
+
+        expect(UrlScrubber.scrubPath(mixed)).toBe(
+          `/org/acme/users/${REDACTED}/orders/2/token/${REDACTED}`,
+        );
+      });
+
+      it("redacts every identifier segment when a path is nothing but ids", () => {
+        expect(
+          UrlScrubber.scrubPath(
+            "/6512f3a9b7c4d2e108f5a3b9/someone@example.com/123456789",
+          ),
+        ).toBe(`/${REDACTED}/${REDACTED}/${REDACTED}`);
+      });
+    });
+  });
+
+  describe("scrubQuery", () => {
+    describe("empty / missing allowlist drops everything", () => {
+      it("returns an empty string when the allowlist is undefined", () => {
+        const params: URLSearchParams = new URLSearchParams(
+          "plan=growth&coupon=SECRET50",
+        );
+
+        expect(UrlScrubber.scrubQuery(params)).toBe("");
+      });
+
+      it("returns an empty string when the allowlist is empty", () => {
+        const params: URLSearchParams = new URLSearchParams("plan=growth");
+
+        expect(UrlScrubber.scrubQuery(params, [])).toBe("");
+      });
+
+      it("returns an empty string when no parameter matches the allowlist", () => {
+        const params: URLSearchParams = new URLSearchParams(
+          "coupon=SECRET50&ref=twitter",
+        );
+
+        expect(UrlScrubber.scrubQuery(params, ["plan"])).toBe("");
+      });
+
+      it("returns an empty string for a query with no parameters at all", () => {
+        expect(UrlScrubber.scrubQuery(new URLSearchParams(""), ["plan"])).toBe(
+          "",
+        );
+      });
+    });
+
+    describe("allowlisted names are kept with redacted values", () => {
+      it("keeps the name and redacts the value of an allowlisted parameter", () => {
+        const params: URLSearchParams = new URLSearchParams(
+          "plan=growth&coupon=SECRET50",
+        );
+
+        const scrubbed: string = UrlScrubber.scrubQuery(params, ["plan"]);
+
+        expect(scrubbed).toBe(`plan=${REDACTED}`);
+        expect(scrubbed).not.toContain("growth");
+        expect(scrubbed).not.toContain("SECRET50");
+        expect(scrubbed).not.toContain("coupon");
+      });
+
+      it("redacts the value regardless of how sensitive it looks", () => {
+        const params: URLSearchParams = new URLSearchParams();
+        params.append("token", "eyJhbGciOiJIUzI1NiJ9.payload.signature");
+
+        const scrubbed: string = UrlScrubber.scrubQuery(params, ["token"]);
+
+        expect(scrubbed).toBe(`token=${REDACTED}`);
+        expect(scrubbed).not.toContain("eyJ");
+      });
+
+      it("keeps several allowlisted parameters joined by ampersands", () => {
+        const params: URLSearchParams = new URLSearchParams(
+          "plan=growth&ref=twitter&step=2",
+        );
+
+        expect(UrlScrubber.scrubQuery(params, ["plan", "step"])).toBe(
+          `plan=${REDACTED}&step=${REDACTED}`,
+        );
+      });
+
+      it("preserves the original query order of the kept parameters", () => {
+        const params: URLSearchParams = new URLSearchParams(
+          "step=2&plan=growth",
+        );
+
+        expect(UrlScrubber.scrubQuery(params, ["plan", "step"])).toBe(
+          `step=${REDACTED}&plan=${REDACTED}`,
+        );
+      });
+    });
+
+    describe("case-insensitive matching", () => {
+      it("matches an allowlist entry against a differently-cased parameter name", () => {
+        const params: URLSearchParams = new URLSearchParams("Plan=growth");
+
+        /*
+         * The comparison lowercases both sides, but the emitted name keeps
+         * the parameter's original casing.
+         */
+        expect(UrlScrubber.scrubQuery(params, ["plan"])).toBe(
+          `Plan=${REDACTED}`,
+        );
+      });
+
+      it("matches when the allowlist entry itself is upper-cased", () => {
+        const params: URLSearchParams = new URLSearchParams("plan=growth");
+
+        expect(UrlScrubber.scrubQuery(params, ["PLAN"])).toBe(
+          `plan=${REDACTED}`,
+        );
+      });
+    });
+
+    describe("edge cases in parameter names", () => {
+      it("emits one redacted entry per repeated occurrence of a key", () => {
+        /*
+         * URLSearchParams keeps duplicate keys, so forEach visits each one;
+         * both are kept, and because the value is redacted the two entries
+         * are identical.
+         */
+        const params: URLSearchParams = new URLSearchParams("a=1&a=2&b=3");
+
+        expect(UrlScrubber.scrubQuery(params, ["a"])).toBe(
+          `a=${REDACTED}&a=${REDACTED}`,
+        );
+      });
+
+      it("percent-encodes an allowlisted key that contains a space", () => {
+        const params: URLSearchParams = new URLSearchParams();
+        params.append("user name", "jane");
+
+        expect(UrlScrubber.scrubQuery(params, ["user name"])).toBe(
+          `user%20name=${REDACTED}`,
+        );
+      });
+    });
+  });
+});

package/Types/Email/EmailTemplateType.ts

@@ -3,6 +3,7 @@ enum EmailTemplateType {
   ForgotPassword = "ForgotPassword.hbs",
   ProbeOffline = "ProbeOffline.hbs",
   SignupWelcomeEmail = "SignupWelcomeEmail.hbs",
+  CompleteRegistration = "CompleteRegistration.hbs",
   ProbeConnectionStatusChange = "ProbeConnectionStatusChange.hbs",
   AIAgentConnectionStatusChange = "AIAgentConnectionStatusChange.hbs",
   AIAgentOwnerAdded = "AIAgentOwnerAdded.hbs",

package/Types/Marketing/MarketingConversion.ts

@@ -1,8 +1,20 @@
 export enum MarketingConversionType {
   SignUp = "SignUp",
+  // A verified Cal.com booking. See Docs/analytics/enterprise-conversion-tracking.md.
+  MeetingBooked = "MeetingBooked",
   PaidSubscription = "PaidSubscription",
 }
 
+/*
+ * Conversion types that ad platforms have an explicit conversion-action
+ * mapping for. Every provider picks its platform conversion action by
+ * branching on SignUp vs not-SignUp, so a type that is not listed here would
+ * be uploaded as a purchase — add a type only once every provider has a
+ * mapping for it. Types left out stay ledger-only and are recorded as Skipped.
+ */
+export const AdUploadableMarketingConversionTypes: Array<MarketingConversionType> =
+  [MarketingConversionType.SignUp, MarketingConversionType.PaidSubscription];
+
 export enum MarketingConversionUploadStatus {
   Uploaded = "Uploaded",
   Failed = "Failed",

package/Types/Monitor/CriteriaFilter.ts

@@ -224,6 +224,14 @@ export enum EvaluateOverTimeMinutes {
 export interface EvaluateOverTimeOptions {
   timeValueInMinutes: number | undefined;
   evaluateOverTimeType: EvaluateOverTimeType | undefined;
+  /*
+   * Governs what happens when the evaluation window cannot back the filter -
+   * either nothing was recorded in it, or the monitor has not been running
+   * long enough to cover it yet. Defaults to Ignore when unset, so a filter
+   * asked to look at the last N minutes waits for N minutes of data instead
+   * of firing off the reading that happens to have just arrived.
+   */
+  onNoDataPolicy?: NoDataPolicy | undefined;
 }
 
 export interface CriteriaFilter {
@@ -449,5 +457,6 @@ export const CriteriaFilterSchema: ZodSchema = Zod.object({
   evaluateOverTimeOptions: Zod.object({
     timeValueInMinutes: Zod.number().optional(),
     evaluateOverTimeType: Zod.string().optional(),
+    onNoDataPolicy: Zod.string().optional(),
   }).optional(),
 });