@oneuptime/common 11.7.3 → 12.0.0

package/Tests/Server/Services/SessionReplayMetering.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "@jest/globals";
+import ProductType from "../../../Types/MeteredPlan/ProductType";
+import AllMeteredPlans, {
+  MeteredPlanUtil,
+  SessionReplayDataIngestMeteredPlan,
+} from "../../../Server/Types/Billing/MeteredPlan/AllMeteredPlans";
+import ServerMeteredPlan from "../../../Server/Types/Billing/MeteredPlan/ServerMeteredPlan";
+import TelemetryMeteredPlan from "../../../Server/Types/Billing/MeteredPlan/TelemetryMeteredPlan";
+import { RumSessionService as RumSessionServiceType } from "../../../Server/Services/RumSessionService";
+import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import ObjectID from "../../../Types/ObjectID";
+import OneUptimeDate from "../../../Types/Date";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * Session replay has to be a first-class metered product alongside logs,
+ * traces, metrics and profiles.
+ *
+ * Several sites in this path throw on an unrecognised ProductType, so a
+ * half-finished registration does not degrade gracefully - it breaks the
+ * telemetry billing run for every pillar. Each of those sites is pinned here.
+ */
+
+describe("Session replay metered plan registration", () => {
+  it("is a ProductType", () => {
+    expect(ProductType.SessionReplay).toBe("Session Replay");
+  });
+
+  it("resolves through MeteredPlanUtil instead of throwing", () => {
+    /*
+     * getMeteredPlanByProductType throws BadDataException on an unknown type.
+     * Adding the enum member without this branch would make every metered
+     * billing run fail the moment it reached session replay.
+     */
+    const plan: ServerMeteredPlan = MeteredPlanUtil.getMeteredPlanByProductType(
+      ProductType.SessionReplay,
+    );
+
+    expect(plan).toBe(SessionReplayDataIngestMeteredPlan);
+    expect(plan.getProductType()).toBe(ProductType.SessionReplay);
+  });
+
+  it("is registered in the AllMeteredPlans array", () => {
+    const productTypes: Array<ProductType> = AllMeteredPlans.map(
+      (plan: ServerMeteredPlan): ProductType => {
+        return plan.getProductType();
+      },
+    );
+
+    expect(productTypes).toContain(ProductType.SessionReplay);
+  });
+
+  it("is a telemetry metered plan, so it bills on GB x retention-days", () => {
+    expect(SessionReplayDataIngestMeteredPlan).toBeInstanceOf(
+      TelemetryMeteredPlan,
+    );
+  });
+
+  it("is priced above the other telemetry pillars", () => {
+    /*
+     * At telemetry parity (0.1 / 15) a project recording 100k sessions a month
+     * bills under a dollar, which does not cover cost. This asserts the
+     * deliberate divergence rather than the exact number, so a future price
+     * change does not have to touch this test unless it drops back to parity.
+     */
+    const telemetryParityRate: number = 0.1 / 15;
+    const sessionReplayPlan: TelemetryMeteredPlan =
+      SessionReplayDataIngestMeteredPlan;
+
+    expect(sessionReplayPlan.unitCostInUSD).toBeGreaterThan(
+      telemetryParityRate,
+    );
+  });
+
+  it("every registered plan resolves back to itself", () => {
+    /*
+     * Guards the enum and the util from drifting apart in either direction.
+     */
+    for (const plan of AllMeteredPlans) {
+      expect(
+        MeteredPlanUtil.getMeteredPlanByProductType(plan.getProductType()),
+      ).toBe(plan);
+    }
+  });
+});
+
+describe("Session replay usage aggregation SQL", () => {
+  /*
+   * This query is the one place a mistake becomes unrecoverable revenue loss
+   * rather than a visible error, so its shape is pinned rather than trusted.
+   *
+   * stageTelemetryUsageForProject always targets YESTERDAY, rethrows, and the
+   * caller only logs - nothing ever re-stages an older date. So if this query
+   * times out, that day is billed as zero permanently.
+   */
+  async function captureUsageQuery(): Promise<string> {
+    const service: RumSessionServiceType = new RumSessionServiceType();
+
+    let captured: string = "";
+
+    /*
+     * Capture the statement instead of running it: this asserts the SQL we
+     * generate, with no ClickHouse in the loop.
+     */
+    service.executeQuery = ((statement: Statement): Promise<unknown> => {
+      captured = `${statement.query} :: ${JSON.stringify(
+        statement.query_params,
+      )}`;
+
+      return Promise.resolve({
+        json: (): Promise<{ data: Array<JSONObject> }> => {
+          return Promise.resolve({ data: [] });
+        },
+      });
+    }) as unknown as typeof service.executeQuery;
+
+    await service.groupSessionReplayUsageByEntity({
+      projectId: new ObjectID("6512f3a9b7c4d2e108f5a3b9"),
+      startDate: OneUptimeDate.getCurrentDate(),
+      endDate: OneUptimeDate.getCurrentDate(),
+    });
+
+    return captured;
+  }
+
+  it("meters off the session header table", async () => {
+    expect(await captureUsageQuery()).toContain("RumSessionV1");
+  });
+
+  it("NEVER touches the chunk table", async () => {
+    /*
+     * Chunks are partitioned by expiry date, so a "yesterday" window over them
+     * cannot prune partitions. It would full-scan a multi-gigabyte blob table
+     * under the 120s cap and bill the day as zero.
+     */
+    expect(await captureUsageQuery()).not.toContain("RumSessionChunkV1");
+  });
+
+  it("sums the exact payloadBytes rather than byteSize(*)", async () => {
+    const sql: string = await captureUsageQuery();
+
+    expect(sql).toContain("sum(payloadBytes)");
+    expect(sql).not.toContain("byteSize");
+  });
+
+  it("excludes provisional headers, whose aggregates are still zero", async () => {
+    expect(await captureUsageQuery()).toContain("isFinalized = 1");
+  });
+
+  it("collapses ReplacingMergeTree versions, since this repo has no FINAL", async () => {
+    /*
+     * Without the dedupe an un-merged duplicate header would be summed twice
+     * and the project over-billed.
+     */
+    const sql: string = await captureUsageQuery();
+
+    expect(sql).toContain("LIMIT 1 BY");
+    expect(sql).toContain("ORDER BY version DESC");
+  });
+
+  it("does not let a partial aggregation look like a complete one", async () => {
+    /*
+     * Deliberately no timeout_overflow_mode='break': that returns partial
+     * results WITHOUT erroring, which would silently undercount.
+     */
+    expect(await captureUsageQuery()).not.toContain("timeout_overflow_mode");
+  });
+
+  it("groups by the owning entity so usage is attributable", async () => {
+    expect(await captureUsageQuery()).toContain(
+      "GROUP BY primaryEntityId, primaryEntityType",
+    );
+  });
+});

package/Tests/Server/Services/StatusPageGroupNesting.test.ts

@@ -0,0 +1,395 @@
+import StatusPageGroupService from "../../../Server/Services/StatusPageGroupService";
+import StatusPageGroup from "../../../Models/DatabaseModels/StatusPageGroup";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import StatusPageGroupTreeUtil from "../../../Utils/StatusPage/GroupTree";
+import { describe, expect, it, afterEach } from "@jest/globals";
+
+/*
+ * Contract under test - the write side of nested status page groups.
+ *
+ * The parent pointer is a plain nullable column, so the service is the only
+ * thing standing between a well formed tree and one that cannot be rendered or
+ * rolled up. It has to reject, on both create and update:
+ *
+ *   - a parent on a different status page (groups roll up per page),
+ *   - a group parented to itself,
+ *   - a group parented to one of its own sub groups (a cycle - which would
+ *     make the group unreachable from any root and its rollups circular),
+ *   - a move that pushes the group, or anything already nested under it,
+ *     past the nesting limit.
+ *
+ * And it must not pay for any of that when the write does not touch the parent.
+ */
+
+const STATUS_PAGE_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const OTHER_STATUS_PAGE_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const PROJECT_ID: ObjectID = new ObjectID(
+  "33333333-3333-4333-8333-333333333333",
+);
+
+function groupId(index: number): ObjectID {
+  const suffix: string = index.toString().padStart(12, "0");
+  return new ObjectID(`aaaaaaaa-aaaa-4aaa-8aaa-${suffix}`);
+}
+
+function makeGroup(data: {
+  id: ObjectID;
+  parentId?: ObjectID | undefined;
+  statusPageId?: ObjectID | undefined;
+}): StatusPageGroup {
+  const group: StatusPageGroup = new StatusPageGroup();
+  group._id = data.id.toString();
+  group.statusPageId = data.statusPageId || STATUS_PAGE_ID;
+
+  if (data.parentId) {
+    group.parentStatusPageGroupId = data.parentId;
+  }
+
+  return group;
+}
+
+/*
+ * Wires up the reads the hooks make: findOneById resolves a parent, findBy
+ * resolves either "every group on the status page" or "the groups this update
+ * matches", and the order bookkeeping is stubbed out so these cases only
+ * exercise the hierarchy rules.
+ */
+function mockService(data: {
+  groupsOnStatusPage: Array<StatusPageGroup>;
+  groupsMatchedByUpdate?: Array<StatusPageGroup> | undefined;
+}): void {
+  jest
+    .spyOn(StatusPageGroupService, "findOneById")
+    .mockImplementation(async (findBy: any) => {
+      return (
+        data.groupsOnStatusPage.find((group: StatusPageGroup) => {
+          return group._id?.toString() === findBy.id?.toString();
+        }) || null
+      );
+    });
+
+  jest
+    .spyOn(StatusPageGroupService, "findBy")
+    .mockImplementation(async (findBy: any) => {
+      if (findBy.query && findBy.query.statusPageId) {
+        return data.groupsOnStatusPage;
+      }
+
+      return data.groupsMatchedByUpdate || [];
+    });
+
+  jest
+    .spyOn(StatusPageGroupService, "countBy")
+    .mockResolvedValue(new PositiveNumber(data.groupsOnStatusPage.length));
+
+  jest.spyOn(StatusPageGroupService, "updateOneBy").mockResolvedValue(1);
+}
+
+function createBy(data: {
+  parentStatusPageGroupId?: ObjectID | undefined;
+  statusPageId?: ObjectID | undefined;
+}): CreateBy<StatusPageGroup> {
+  const group: StatusPageGroup = new StatusPageGroup();
+  group.name = "New Group";
+  group.projectId = PROJECT_ID;
+  group.statusPageId = data.statusPageId || STATUS_PAGE_ID;
+  group.order = 1;
+
+  if (data.parentStatusPageGroupId) {
+    group.parentStatusPageGroupId = data.parentStatusPageGroupId;
+  }
+
+  return {
+    data: group,
+    props: { isRoot: true },
+  } as CreateBy<StatusPageGroup>;
+}
+
+function updateBy(data: {
+  id: ObjectID;
+  parentStatusPageGroupId: ObjectID | null;
+}): UpdateBy<StatusPageGroup> {
+  return {
+    query: { _id: data.id.toString() },
+    data: {
+      parentStatusPageGroupId: data.parentStatusPageGroupId,
+    },
+    props: { isRoot: true },
+  } as unknown as UpdateBy<StatusPageGroup>;
+}
+
+describe("StatusPageGroupService nesting rules", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("on create", () => {
+    it("accepts a parent that lives on the same status page", async () => {
+      const parent: StatusPageGroup = makeGroup({ id: groupId(1) });
+      mockService({ groupsOnStatusPage: [parent] });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeCreate(
+          createBy({ parentStatusPageGroupId: groupId(1) }),
+        ),
+      ).resolves.toBeDefined();
+    });
+
+    it("rejects a parent that does not exist", async () => {
+      mockService({ groupsOnStatusPage: [] });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeCreate(
+          createBy({ parentStatusPageGroupId: groupId(1) }),
+        ),
+      ).rejects.toThrow(new BadDataException("Parent group not found."));
+    });
+
+    it("rejects a parent from another status page", async () => {
+      const parent: StatusPageGroup = makeGroup({
+        id: groupId(1),
+        statusPageId: OTHER_STATUS_PAGE_ID,
+      });
+      mockService({ groupsOnStatusPage: [parent] });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeCreate(
+          createBy({ parentStatusPageGroupId: groupId(1) }),
+        ),
+      ).rejects.toThrow(
+        new BadDataException(
+          "Parent group must belong to the same status page.",
+        ),
+      );
+    });
+
+    it("rejects a parent that is already at the nesting limit", async () => {
+      // a chain 0 -> 1 -> ... -> 9, so group 9 already sits at the deepest level.
+      const chain: Array<StatusPageGroup> = [];
+
+      for (
+        let index: number = 0;
+        index < StatusPageGroupTreeUtil.MaxNestingDepth;
+        index++
+      ) {
+        chain.push(
+          makeGroup({
+            id: groupId(index),
+            parentId: index === 0 ? undefined : groupId(index - 1),
+          }),
+        );
+      }
+
+      mockService({ groupsOnStatusPage: chain });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeCreate(
+          createBy({
+            parentStatusPageGroupId: groupId(
+              StatusPageGroupTreeUtil.MaxNestingDepth - 1,
+            ),
+          }),
+        ),
+      ).rejects.toThrow(BadDataException);
+
+      // one level up is still fine.
+      await expect(
+        (StatusPageGroupService as any).onBeforeCreate(
+          createBy({
+            parentStatusPageGroupId: groupId(
+              StatusPageGroupTreeUtil.MaxNestingDepth - 2,
+            ),
+          }),
+        ),
+      ).resolves.toBeDefined();
+    });
+
+    it("does not look for a parent when none was supplied", async () => {
+      mockService({ groupsOnStatusPage: [] });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeCreate(createBy({})),
+      ).resolves.toBeDefined();
+
+      expect(StatusPageGroupService.findOneById).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("on update", () => {
+    it("accepts a move to another branch", async () => {
+      const branchA: StatusPageGroup = makeGroup({ id: groupId(1) });
+      const branchB: StatusPageGroup = makeGroup({ id: groupId(2) });
+      const moving: StatusPageGroup = makeGroup({
+        id: groupId(3),
+        parentId: groupId(1),
+      });
+
+      mockService({
+        groupsOnStatusPage: [branchA, branchB, moving],
+        groupsMatchedByUpdate: [moving],
+      });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(
+          updateBy({ id: groupId(3), parentStatusPageGroupId: groupId(2) }),
+        ),
+      ).resolves.toBeDefined();
+    });
+
+    it("rejects a group being made its own parent", async () => {
+      const group: StatusPageGroup = makeGroup({ id: groupId(1) });
+
+      mockService({
+        groupsOnStatusPage: [group],
+        groupsMatchedByUpdate: [group],
+      });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(
+          updateBy({ id: groupId(1), parentStatusPageGroupId: groupId(1) }),
+        ),
+      ).rejects.toThrow(
+        new BadDataException("A group cannot be its own parent group."),
+      );
+    });
+
+    it("rejects a group being nested under its own child", async () => {
+      const parent: StatusPageGroup = makeGroup({ id: groupId(1) });
+      const child: StatusPageGroup = makeGroup({
+        id: groupId(2),
+        parentId: groupId(1),
+      });
+
+      mockService({
+        groupsOnStatusPage: [parent, child],
+        groupsMatchedByUpdate: [parent],
+      });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(
+          updateBy({ id: groupId(1), parentStatusPageGroupId: groupId(2) }),
+        ),
+      ).rejects.toThrow(
+        new BadDataException(
+          "This group cannot be nested under one of its own sub groups.",
+        ),
+      );
+    });
+
+    it("rejects a group being nested under a deeper descendant", async () => {
+      const grandparent: StatusPageGroup = makeGroup({ id: groupId(1) });
+      const parent: StatusPageGroup = makeGroup({
+        id: groupId(2),
+        parentId: groupId(1),
+      });
+      const child: StatusPageGroup = makeGroup({
+        id: groupId(3),
+        parentId: groupId(2),
+      });
+
+      mockService({
+        groupsOnStatusPage: [grandparent, parent, child],
+        groupsMatchedByUpdate: [grandparent],
+      });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(
+          updateBy({ id: groupId(1), parentStatusPageGroupId: groupId(3) }),
+        ),
+      ).rejects.toThrow(
+        new BadDataException(
+          "This group cannot be nested under one of its own sub groups.",
+        ),
+      );
+    });
+
+    /*
+     * Moving a group drags its whole subtree with it, so the limit has to be
+     * checked against the deepest descendant, not just the group itself.
+     */
+    it("rejects a move that would push the group's own subtree past the limit", async () => {
+      const chain: Array<StatusPageGroup> = [];
+
+      for (
+        let index: number = 0;
+        index < StatusPageGroupTreeUtil.MaxNestingDepth - 1;
+        index++
+      ) {
+        chain.push(
+          makeGroup({
+            id: groupId(index),
+            parentId: index === 0 ? undefined : groupId(index - 1),
+          }),
+        );
+      }
+
+      // a separate two level branch: 100 -> 101.
+      const movingRoot: StatusPageGroup = makeGroup({ id: groupId(100) });
+      const movingChild: StatusPageGroup = makeGroup({
+        id: groupId(101),
+        parentId: groupId(100),
+      });
+
+      mockService({
+        groupsOnStatusPage: [...chain, movingRoot, movingChild],
+        groupsMatchedByUpdate: [movingRoot],
+      });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(
+          updateBy({
+            id: groupId(100),
+            parentStatusPageGroupId: groupId(
+              StatusPageGroupTreeUtil.MaxNestingDepth - 2,
+            ),
+          }),
+        ),
+      ).rejects.toThrow(BadDataException);
+    });
+
+    it("does not validate a parent when the update detaches the group", async () => {
+      const group: StatusPageGroup = makeGroup({
+        id: groupId(1),
+        parentId: groupId(2),
+      });
+
+      mockService({
+        groupsOnStatusPage: [group],
+        groupsMatchedByUpdate: [group],
+      });
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(
+          updateBy({ id: groupId(1), parentStatusPageGroupId: null }),
+        ),
+      ).resolves.toBeDefined();
+
+      expect(StatusPageGroupService.findOneById).not.toHaveBeenCalled();
+    });
+
+    it("does not read anything when the update does not touch the parent", async () => {
+      mockService({ groupsOnStatusPage: [] });
+
+      const update: UpdateBy<StatusPageGroup> = {
+        query: { _id: groupId(1).toString() },
+        data: { name: "Renamed" },
+        props: { isRoot: true },
+      } as unknown as UpdateBy<StatusPageGroup>;
+
+      await expect(
+        (StatusPageGroupService as any).onBeforeUpdate(update),
+      ).resolves.toBeDefined();
+
+      expect(StatusPageGroupService.findOneById).not.toHaveBeenCalled();
+      expect(StatusPageGroupService.findBy).not.toHaveBeenCalled();
+    });
+  });
+});