@oneuptime/common 14.0.3 → 14.0.6

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

@@ -0,0 +1,402 @@
+import LlmModelPrice from "../../../Models/DatabaseModels/LlmModelPrice";
+import LlmModelPriceService from "../../../Server/Services/LlmModelPriceService";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * The create/update hooks are protected; reach them the way the
+ * DatabaseService pipeline does, through the singleton instance. Price and
+ * prefix validation is pure, so the only calls that need stubbing are the
+ * duplicate-prefix lookups (findOneBy / findBy), which are stubbed per test.
+ */
+type HookAccess = {
+  onBeforeCreate: (
+    createBy: CreateBy<LlmModelPrice>,
+  ) => Promise<{ createBy: CreateBy<LlmModelPrice> }>;
+  onBeforeUpdate: (
+    updateBy: UpdateBy<LlmModelPrice>,
+  ) => Promise<{ updateBy: UpdateBy<LlmModelPrice> }>;
+};
+
+const service: HookAccess = LlmModelPriceService as unknown as HookAccess;
+
+/*
+ * Spy handles are held through this rather than a SpyInstance type: two
+ * SpyInstance declarations are in scope in this project (the global jest
+ * namespace's two-parameter form and @jest/globals' one-parameter form), and
+ * naming the wrong one type-checks nowhere but fails only in the compile job.
+ * These tests read exactly one thing off a spy, so that is all this names.
+ */
+interface SpyCalls {
+  mock: { calls: Array<Array<unknown>> };
+}
+
+/*
+ * Explicit `| undefined` on every field rather than Partial<LlmModelPrice>:
+ * the tests below deliberately pass undefined to prove it is rejected, and
+ * under exactOptionalPropertyTypes an optional property is not the same as a
+ * property that accepts undefined.
+ */
+interface PriceOverrides {
+  modelPrefix?: string | undefined;
+  inputPricePerMillionTokensInUSD?: number | undefined;
+  outputPricePerMillionTokensInUSD?: number | undefined;
+  projectId?: ObjectID | undefined;
+}
+
+function makeCreateBy(data: PriceOverrides): CreateBy<LlmModelPrice> {
+  const price: LlmModelPrice = new LlmModelPrice();
+  Object.assign(price, data);
+
+  return {
+    data: price,
+    props: { isRoot: true },
+  } as CreateBy<LlmModelPrice>;
+}
+
+function makeUpdateBy(data: Record<string, unknown>): UpdateBy<LlmModelPrice> {
+  return {
+    query: {},
+    data: data,
+    props: { isRoot: true },
+  } as unknown as UpdateBy<LlmModelPrice>;
+}
+
+// A create payload that carries no projectId never reaches a duplicate lookup.
+function validCreate(overrides: PriceOverrides = {}): CreateBy<LlmModelPrice> {
+  return makeCreateBy({
+    modelPrefix: "gpt-4o",
+    inputPricePerMillionTokensInUSD: 5,
+    outputPricePerMillionTokensInUSD: 15,
+    ...overrides,
+  });
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("LlmModelPriceService.onBeforeCreate — modelPrefix", () => {
+  test("keeps a well-formed prefix", async () => {
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(validCreate());
+
+    expect(result.createBy.data.modelPrefix).toBe("gpt-4o");
+  });
+
+  /*
+   * Prefixes are matched lowercase against normalized model names at ingest
+   * time, so an entry saved with any other casing would never price anything.
+   */
+  test("lowercases the prefix so ingest-time matching can find it", async () => {
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(validCreate({ modelPrefix: "GPT-4o" }));
+
+    expect(result.createBy.data.modelPrefix).toBe("gpt-4o");
+  });
+
+  test("trims surrounding whitespace before lowercasing", async () => {
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(
+        validCreate({ modelPrefix: "  Claude-Opus  " }),
+      );
+
+    expect(result.createBy.data.modelPrefix).toBe("claude-opus");
+  });
+
+  test.each([
+    ["missing", undefined],
+    ["empty string", ""],
+    ["whitespace only", "   "],
+    ["a number", 42],
+    ["null", null],
+  ])("rejects a prefix that is %s", async (_label: string, value: unknown) => {
+    await expect(
+      service.onBeforeCreate(
+        validCreate({ modelPrefix: value as string | undefined }),
+      ),
+    ).rejects.toThrow(BadDataException);
+  });
+});
+
+describe("LlmModelPriceService.onBeforeCreate — prices", () => {
+  test("accepts zero, which is how a free model is priced", async () => {
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(
+        validCreate({
+          inputPricePerMillionTokensInUSD: 0,
+          outputPricePerMillionTokensInUSD: 0,
+        }),
+      );
+
+    expect(result.createBy.data.inputPricePerMillionTokensInUSD).toBe(0);
+    expect(result.createBy.data.outputPricePerMillionTokensInUSD).toBe(0);
+  });
+
+  test("accepts fractional prices", async () => {
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(
+        validCreate({
+          inputPricePerMillionTokensInUSD: 0.15,
+          outputPricePerMillionTokensInUSD: 0.075,
+        }),
+      );
+
+    expect(result.createBy.data.inputPricePerMillionTokensInUSD).toBe(0.15);
+    expect(result.createBy.data.outputPricePerMillionTokensInUSD).toBe(0.075);
+  });
+
+  /*
+   * The dashboard's number fields hand Formik `e.target.value`, so numeric
+   * columns can arrive as strings. They must be written back as numbers so
+   * Postgres never sees a string either.
+   */
+  test("coerces numeric strings back onto the payload as numbers", async () => {
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(
+        validCreate({
+          inputPricePerMillionTokensInUSD: "2.50" as unknown as number,
+          outputPricePerMillionTokensInUSD: "10" as unknown as number,
+        }),
+      );
+
+    expect(result.createBy.data.inputPricePerMillionTokensInUSD).toBe(2.5);
+    expect(typeof result.createBy.data.inputPricePerMillionTokensInUSD).toBe(
+      "number",
+    );
+    expect(result.createBy.data.outputPricePerMillionTokensInUSD).toBe(10);
+    expect(typeof result.createBy.data.outputPricePerMillionTokensInUSD).toBe(
+      "number",
+    );
+  });
+
+  test.each([
+    ["negative", -1],
+    ["NaN string", "not-a-number"],
+    ["empty string", ""],
+    ["whitespace only", "   "],
+    ["missing", undefined],
+    ["null", null],
+    ["Infinity", Number.POSITIVE_INFINITY],
+  ])(
+    "rejects an input price that is %s",
+    async (_label: string, value: unknown) => {
+      await expect(
+        service.onBeforeCreate(
+          validCreate({
+            inputPricePerMillionTokensInUSD: value as number | undefined,
+          }),
+        ),
+      ).rejects.toThrow(BadDataException);
+    },
+  );
+
+  test("rejects a negative output price", async () => {
+    await expect(
+      service.onBeforeCreate(
+        validCreate({ outputPricePerMillionTokensInUSD: -0.01 }),
+      ),
+    ).rejects.toThrow(BadDataException);
+  });
+
+  test("names the offending field in the error message", async () => {
+    await expect(
+      service.onBeforeCreate(
+        validCreate({ outputPricePerMillionTokensInUSD: -1 }),
+      ),
+    ).rejects.toThrow(/Output price/);
+
+    await expect(
+      service.onBeforeCreate(
+        validCreate({ inputPricePerMillionTokensInUSD: -1 }),
+      ),
+    ).rejects.toThrow(/Input price/);
+  });
+});
+
+describe("LlmModelPriceService.onBeforeCreate — duplicate prefixes", () => {
+  /*
+   * Two entries with the same prefix make the ingest-time price lookup
+   * ambiguous (first-loaded wins), so the duplicate is refused at write time.
+   */
+  test("rejects a prefix the project already prices", async () => {
+    const existing: LlmModelPrice = new LlmModelPrice();
+    existing._id = new ObjectID(
+      "11111111-1111-4111-8111-111111111111",
+    ).toString();
+
+    const findOneBy: SpyCalls = jest
+      .spyOn(LlmModelPriceService, "findOneBy")
+      .mockResolvedValue(existing as never) as unknown as SpyCalls;
+
+    await expect(
+      service.onBeforeCreate(
+        validCreate({
+          projectId: new ObjectID("22222222-2222-4222-8222-222222222222"),
+        }),
+      ),
+    ).rejects.toThrow(BadDataException);
+
+    expect(findOneBy.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  test("looks the duplicate up by the NORMALIZED prefix, not the raw input", async () => {
+    const findOneBy: SpyCalls = jest
+      .spyOn(LlmModelPriceService, "findOneBy")
+      .mockResolvedValue(null as never) as unknown as SpyCalls;
+
+    await service.onBeforeCreate(
+      validCreate({
+        modelPrefix: "  GPT-4O  ",
+        projectId: new ObjectID("22222222-2222-4222-8222-222222222222"),
+      }),
+    );
+
+    const query: { modelPrefix?: string } = (
+      findOneBy.mock.calls[0]![0] as unknown as {
+        query: { modelPrefix?: string };
+      }
+    ).query;
+
+    expect(query.modelPrefix).toBe("gpt-4o");
+  });
+
+  test("allows the prefix when the project has no entry for it", async () => {
+    jest
+      .spyOn(LlmModelPriceService, "findOneBy")
+      .mockResolvedValue(null as never);
+
+    const result: { createBy: CreateBy<LlmModelPrice> } =
+      await service.onBeforeCreate(
+        validCreate({
+          projectId: new ObjectID("22222222-2222-4222-8222-222222222222"),
+        }),
+      );
+
+    expect(result.createBy.data.modelPrefix).toBe("gpt-4o");
+  });
+});
+
+describe("LlmModelPriceService.onBeforeUpdate", () => {
+  test("coerces and validates updated prices", async () => {
+    const result: { updateBy: UpdateBy<LlmModelPrice> } =
+      await service.onBeforeUpdate(
+        makeUpdateBy({
+          inputPricePerMillionTokensInUSD: "3.25",
+          outputPricePerMillionTokensInUSD: "9",
+        }),
+      );
+
+    expect(result.updateBy.data.inputPricePerMillionTokensInUSD).toBe(3.25);
+    expect(result.updateBy.data.outputPricePerMillionTokensInUSD).toBe(9);
+  });
+
+  test("rejects a negative updated price", async () => {
+    await expect(
+      service.onBeforeUpdate(
+        makeUpdateBy({ inputPricePerMillionTokensInUSD: -4 }),
+      ),
+    ).rejects.toThrow(BadDataException);
+  });
+
+  /*
+   * A partial update that does not mention a field must leave it alone rather
+   * than validating `undefined` and failing the whole write.
+   */
+  test("leaves untouched fields alone", async () => {
+    const result: { updateBy: UpdateBy<LlmModelPrice> } =
+      await service.onBeforeUpdate(
+        makeUpdateBy({ inputPricePerMillionTokensInUSD: 1 }),
+      );
+
+    expect(result.updateBy.data.inputPricePerMillionTokensInUSD).toBe(1);
+    expect(
+      result.updateBy.data.outputPricePerMillionTokensInUSD,
+    ).toBeUndefined();
+  });
+
+  test("accepts an update that changes nothing at all", async () => {
+    const result: { updateBy: UpdateBy<LlmModelPrice> } =
+      await service.onBeforeUpdate(makeUpdateBy({}));
+
+    expect(result.updateBy.data).toEqual({});
+  });
+
+  test("normalizes a renamed prefix", async () => {
+    jest.spyOn(LlmModelPriceService, "findBy").mockResolvedValue([] as never);
+
+    const result: { updateBy: UpdateBy<LlmModelPrice> } =
+      await service.onBeforeUpdate(
+        makeUpdateBy({ modelPrefix: "  Claude-SONNET " }),
+      );
+
+    expect(result.updateBy.data.modelPrefix).toBe("claude-sonnet");
+  });
+
+  test("rejects renaming a prefix onto one a sibling row already uses", async () => {
+    const rowBeingUpdated: LlmModelPrice = new LlmModelPrice();
+    rowBeingUpdated._id = new ObjectID(
+      "33333333-3333-4333-8333-333333333333",
+    ).toString();
+    rowBeingUpdated.projectId = new ObjectID(
+      "22222222-2222-4222-8222-222222222222",
+    );
+
+    const sibling: LlmModelPrice = new LlmModelPrice();
+    sibling._id = new ObjectID(
+      "44444444-4444-4444-8444-444444444444",
+    ).toString();
+
+    jest
+      .spyOn(LlmModelPriceService, "findBy")
+      .mockResolvedValue([rowBeingUpdated] as never);
+    jest
+      .spyOn(LlmModelPriceService, "findOneBy")
+      .mockResolvedValue(sibling as never);
+
+    await expect(
+      service.onBeforeUpdate(makeUpdateBy({ modelPrefix: "gpt-4o" })),
+    ).rejects.toThrow(BadDataException);
+  });
+
+  /*
+   * Re-saving a row without changing its prefix finds itself. That is not a
+   * duplicate, and refusing it would make the edit form unusable.
+   */
+  test("allows a row to keep its own prefix", async () => {
+    const rowBeingUpdated: LlmModelPrice = new LlmModelPrice();
+    rowBeingUpdated._id = new ObjectID(
+      "33333333-3333-4333-8333-333333333333",
+    ).toString();
+    rowBeingUpdated.projectId = new ObjectID(
+      "22222222-2222-4222-8222-222222222222",
+    );
+
+    jest
+      .spyOn(LlmModelPriceService, "findBy")
+      .mockResolvedValue([rowBeingUpdated] as never);
+    jest
+      .spyOn(LlmModelPriceService, "findOneBy")
+      .mockResolvedValue(rowBeingUpdated as never);
+
+    const result: { updateBy: UpdateBy<LlmModelPrice> } =
+      await service.onBeforeUpdate(makeUpdateBy({ modelPrefix: "gpt-4o" }));
+
+    expect(result.updateBy.data.modelPrefix).toBe("gpt-4o");
+  });
+
+  test("rejects an empty renamed prefix without touching the database", async () => {
+    const findBy: SpyCalls = jest
+      .spyOn(LlmModelPriceService, "findBy")
+      .mockResolvedValue([] as never) as unknown as SpyCalls;
+
+    await expect(
+      service.onBeforeUpdate(makeUpdateBy({ modelPrefix: "   " })),
+    ).rejects.toThrow(BadDataException);
+
+    expect(findBy.mock.calls).toHaveLength(0);
+  });
+});

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

@@ -203,6 +203,18 @@ describe("MetricService aggregate statement generation", () => {
       expect(query).not.toContain("__attr_grp_0");
       expect(query).toContain("GROUP BY time");
     });
+
+    it("computes P75 - the Core Web Vitals level - over the histogram buckets", () => {
+      const query: string = getQuery(
+        buildAggregateBy({
+          aggregationType: AggregationType.P75,
+          groupByAttributeKeys: ["app.route"],
+        }),
+      );
+
+      expect(query).toContain("quantileExactWeighted(0.75)");
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+    });
   });
 
   /*

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

@@ -30,6 +30,7 @@ import KubernetesClusterService from "../../../Server/Services/KubernetesCluster
 import ProxmoxClusterService from "../../../Server/Services/ProxmoxClusterService";
 import VMwareVCenterService from "../../../Server/Services/VMwareVCenterService";
 import CephClusterService from "../../../Server/Services/CephClusterService";
+import DatabaseServerService from "../../../Server/Services/DatabaseServerService";
 import DockerSwarmClusterService from "../../../Server/Services/DockerSwarmClusterService";
 import IoTFleetService from "../../../Server/Services/IoTFleetService";
 import ServerlessFunctionService from "../../../Server/Services/ServerlessFunctionService";
@@ -50,7 +51,7 @@ import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
  * `resolveTelemetryResource` has run, and none of the three consults the
  * dictionary before calling in. So every resource block of every batch paid
  * that SELECT. The memo (keyed on entityType + entityId, 60s TTL) is what
- * actually removes it; this suite pins that for ALL twelve entity types.
+ * actually removes it; this suite pins that for ALL thirteen entity types.
  *
  * What is pinned, per type:
  *
@@ -135,6 +136,11 @@ const RETENTION_CASES: Array<RetentionCase> = [
     serviceType: ServiceType.RealUserMonitor,
     service: RumApplicationService,
   },
+  {
+    name: "DatabaseServer",
+    serviceType: ServiceType.DatabaseServer,
+    service: DatabaseServerService,
+  },
 ];
 
 const PROJECT_DEFAULT_RETENTION_DAYS: number = 15;

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

@@ -110,6 +110,31 @@ const OWNER_MODEL_CASES: Array<[string, OwnerModel]> = OWNER_MODELS.map(
   },
 );
 
+/*
+ * Owner tables created AFTER MakeOwnerRowsUnique1793500000000 shipped. Their
+ * own create-table migration builds the unique index from the start, so there
+ * was never anything for 1793500000000 to repair or re-index - it cannot name
+ * a table that did not exist yet. The registry sweep above still holds them to
+ * both guarantees; only the migration's own sweep skips them.
+ *
+ * Only ever append here, and only for a model whose table is new.
+ */
+const OWNER_TABLES_CREATED_AFTER_MIGRATION: Array<string> = [
+  "DatabaseServerOwnerTeam",
+  "DatabaseServerOwnerUser",
+];
+
+const MIGRATED_OWNER_MODELS: Array<OwnerModel> = OWNER_MODELS.filter(
+  (ownerModel: OwnerModel): boolean => {
+    return !OWNER_TABLES_CREATED_AFTER_MIGRATION.includes(ownerModel.tableName);
+  },
+);
+
+const MIGRATED_OWNER_MODEL_CASES: Array<[string, OwnerModel]> =
+  MIGRATED_OWNER_MODELS.map((ownerModel: OwnerModel): [string, OwnerModel] => {
+    return [ownerModel.className, ownerModel];
+  });
+
 function classIndexes(modelType: ModelType): Array<IndexMetadataArgs> {
   return getMetadataArgsStorage().indices.filter(
     (index: IndexMetadataArgs): boolean => {
@@ -290,6 +315,31 @@ describe("MakeOwnerRowsUnique1793500000000", () => {
     expect(SchemaMigrations).toContain(MakeOwnerRowsUnique1793500000000);
   });
 
+  test("skips only owner tables it could not have known, and they are real", async () => {
+    /*
+     * The exemption list must not rot into a way to skip a table this
+     * migration really does repair: every entry is a registered owner model,
+     * and none of them appears anywhere in the migration's statements.
+     */
+    const statements: Array<string> = await runUp();
+    const registered: Array<string> = OWNER_MODELS.map((m: OwnerModel) => {
+      return m.tableName;
+    });
+
+    for (const tableName of OWNER_TABLES_CREATED_AFTER_MIGRATION) {
+      expect(registered).toContain(tableName);
+      expect(
+        statements.some((s: string) => {
+          return s.includes(`"${tableName}"`);
+        }),
+      ).toBe(false);
+    }
+
+    expect(MIGRATED_OWNER_MODELS.length).toBe(
+      OWNER_MODELS.length - OWNER_TABLES_CREATED_AFTER_MIGRATION.length,
+    );
+  });
+
   test("has a name that matches its class, as TypeORM records it", () => {
     expect(new MakeOwnerRowsUnique1793500000000().name).toBe(
       "MakeOwnerRowsUnique1793500000000",
@@ -302,9 +352,9 @@ describe("MakeOwnerRowsUnique1793500000000", () => {
       return s.startsWith("CREATE UNIQUE INDEX");
     });
 
-    expect(creates).toHaveLength(OWNER_MODELS.length);
+    expect(creates).toHaveLength(MIGRATED_OWNER_MODELS.length);
 
-    for (const ownerModel of OWNER_MODELS) {
+    for (const ownerModel of MIGRATED_OWNER_MODELS) {
       const columns: string = ownerModel.uniqueColumns
         .map((column: string): string => {
           return `"${column}"`;
@@ -327,9 +377,9 @@ describe("MakeOwnerRowsUnique1793500000000", () => {
       return s.includes("DELETE FROM");
     });
 
-    expect(deletes).toHaveLength(OWNER_MODELS.length);
+    expect(deletes).toHaveLength(MIGRATED_OWNER_MODELS.length);
 
-    for (const ownerModel of OWNER_MODELS) {
+    for (const ownerModel of MIGRATED_OWNER_MODELS) {
       expect(dedupeStatementFor(statements, ownerModel.tableName)).toHaveLength(
         1,
       );
@@ -376,7 +426,7 @@ describe("MakeOwnerRowsUnique1793500000000", () => {
     }
   });
 
-  describe.each(OWNER_MODEL_CASES)(
+  describe.each(MIGRATED_OWNER_MODEL_CASES)(
     "repair of %s",
     (_name: string, ownerModel: OwnerModel) => {
       async function repairSql(): Promise<string> {
@@ -436,7 +486,7 @@ describe("MakeOwnerRowsUnique1793500000000", () => {
   test("down() drops every unique index", async () => {
     const statements: Array<string> = await runDown();
 
-    for (const ownerModel of OWNER_MODELS) {
+    for (const ownerModel of MIGRATED_OWNER_MODELS) {
       expect(statements).toContain(
         `DROP INDEX "public"."${expectedIndexName(ownerModel)}"`,
       );
@@ -477,9 +527,11 @@ describe("MakeOwnerRowsUnique1793500000000", () => {
 
     for (const statement of restored) {
       const table: string = statement.match(/ON "(\w+)"/)![1]!;
-      const ownerModel: OwnerModel = OWNER_MODELS.find((m: OwnerModel) => {
-        return m.tableName === table;
-      })!;
+      const ownerModel: OwnerModel = MIGRATED_OWNER_MODELS.find(
+        (m: OwnerModel) => {
+          return m.tableName === table;
+        },
+      )!;
 
       expect(statement).toBe(
         `CREATE INDEX "${expectedIndexName(ownerModel)}" ON "${table}" (${ownerModel.uniqueColumns