@oneuptime/common 11.6.1 → 11.7.0

package/Tests/Models/AnalyticsModels/KubernetesCostAllocation.test.ts

@@ -0,0 +1,135 @@
+import KubernetesCostAllocation from "../../../Models/AnalyticsModels/KubernetesCostAllocation";
+import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+import Permission from "../../../Types/Permission";
+
+describe("Analytics KubernetesCostAllocation model", () => {
+  const model: KubernetesCostAllocation = new KubernetesCostAllocation();
+
+  test("has the expected table identity and API path", () => {
+    expect(model.tableName).toBe("KubernetesCostAllocationV1");
+    expect(model.crudApiPath?.toString()).toBe("/kubernetes-cost-allocation");
+  });
+
+  test("sorts and partitions by cluster and window", () => {
+    expect(model.sortKeys).toEqual([
+      "projectId",
+      "kubernetesClusterId",
+      "windowStart",
+      "namespace",
+    ]);
+    expect(model.primaryKeys).toEqual(model.sortKeys);
+    expect(model.partitionKey).toBe("toYYYYMMDD(windowStart)");
+    expect(model.shardingKey).toBe(
+      "cityHash64(projectId, kubernetesClusterId)",
+    );
+  });
+
+  test("expires rows via the retentionDate TTL", () => {
+    expect(model.ttlExpression).toBe("retentionDate DELETE");
+    const retentionDate: AnalyticsTableColumn | null =
+      model.getTableColumn("retentionDate");
+    expect(retentionDate?.type).toBe(TableColumnType.Date);
+  });
+
+  test("declares every cost / usage / efficiency measure as a required Decimal", () => {
+    const measures: Array<string> = [
+      "cpuCoreHours",
+      "cpuCoreRequestAverage",
+      "cpuCoreUsageAverage",
+      "cpuCost",
+      "gpuHours",
+      "gpuCost",
+      "ramByteHours",
+      "ramBytesRequestAverage",
+      "ramBytesUsageAverage",
+      "ramCost",
+      "pvByteHours",
+      "pvCost",
+      "networkCost",
+      "loadBalancerCost",
+      "sharedCost",
+      "externalCost",
+      "totalCost",
+      "cpuEfficiency",
+      "ramEfficiency",
+      "totalEfficiency",
+    ];
+
+    for (const key of measures) {
+      const column: AnalyticsTableColumn | null = model.getTableColumn(key);
+      expect(column).not.toBeNull();
+      expect(column?.type).toBe(TableColumnType.Decimal);
+      expect(column?.required).toBe(true);
+    }
+  });
+
+  test("declares the workload identity dimensions", () => {
+    const dimensions: Array<string> = [
+      "clusterName",
+      "k8sClusterEntityKey",
+      "namespace",
+      "controllerKind",
+      "controllerName",
+      "podName",
+      "containerName",
+      "nodeName",
+      "providerId",
+      "currency",
+    ];
+
+    for (const key of dimensions) {
+      const column: AnalyticsTableColumn | null = model.getTableColumn(key);
+      expect(column).not.toBeNull();
+      expect(column?.type).toBe(TableColumnType.Text);
+    }
+
+    expect(model.getTableColumn("windowStart")?.type).toBe(
+      TableColumnType.DateTime64,
+    );
+    expect(model.getTableColumn("windowEnd")?.type).toBe(
+      TableColumnType.DateTime64,
+    );
+    expect(model.getTableColumn("kubernetesClusterId")?.type).toBe(
+      TableColumnType.ObjectID,
+    );
+  });
+
+  test("stores labels as a map with an extracted key column", () => {
+    const labels: AnalyticsTableColumn | null = model.getTableColumn("labels");
+    expect(labels?.type).toBe(TableColumnType.MapStringString);
+    expect(labels?.mapKeysColumn).toBe("labelKeys");
+
+    const labelKeys: AnalyticsTableColumn | null =
+      model.getTableColumn("labelKeys");
+    expect(labelKeys?.type).toBe(TableColumnType.ArrayText);
+  });
+
+  test("access control mirrors the KubernetesCluster model", () => {
+    expect(model.accessControl?.read).toContain(
+      Permission.ReadKubernetesCluster,
+    );
+    expect(model.accessControl?.create).toContain(
+      Permission.CreateKubernetesCluster,
+    );
+    expect(model.accessControl?.delete).toContain(
+      Permission.DeleteKubernetesCluster,
+    );
+    // Cost rows are immutable facts — nothing may update them.
+    expect(model.accessControl?.update).toEqual([]);
+  });
+
+  test("deserializes ClickHouse DateTime64 window values as Dates", () => {
+    const row: KubernetesCostAllocation = KubernetesCostAllocation.fromJSON(
+      {
+        windowStart: "2026-07-24 10:00:00.000000000",
+        windowEnd: "2026-07-24 11:00:00.000000000",
+      },
+      KubernetesCostAllocation,
+    ) as KubernetesCostAllocation;
+
+    expect(row.windowStart).toBeInstanceOf(Date);
+    expect(row.windowStart?.toISOString()).toBe("2026-07-24T10:00:00.000Z");
+    expect(row.windowEnd?.toISOString()).toBe("2026-07-24T11:00:00.000Z");
+  });
+});

package/Tests/Models/NetworkSiteHierarchy.test.ts

@@ -0,0 +1,134 @@
+/**
+ * NetworkSite hierarchy model contracts.
+ *
+ * NetworkSite is the schema's first self-nesting container: parentSite is a
+ * ManyToOne pointing back at NetworkSite itself. That self-reference is easy
+ * to break silently — a lazy-arrow typo or a decorator reorder leaves tsc
+ * green while TypeORM builds a relation to the wrong target. The FK actions
+ * are pinned too, because they carry the deletion semantics of the whole
+ * hierarchy: deleting a parent must orphan (SET NULL) its children, not
+ * cascade the subtree away, while timelines/links/rules die with their site.
+ */
+
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
+import NetworkEndpoint from "../../Models/DatabaseModels/NetworkEndpoint";
+import NetworkSite from "../../Models/DatabaseModels/NetworkSite";
+import NetworkSiteAssignmentRule from "../../Models/DatabaseModels/NetworkSiteAssignmentRule";
+import NetworkSiteLink from "../../Models/DatabaseModels/NetworkSiteLink";
+import NetworkSiteStatusTimeline from "../../Models/DatabaseModels/NetworkSiteStatusTimeline";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import { getUniqueColumnBy } from "../../Types/Database/UniqueColumnBy";
+import GenericFunction from "../../Types/GenericFunction";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import { RelationMetadataArgs } from "typeorm/metadata-args/RelationMetadataArgs";
+
+function relationArgs(
+  target: GenericFunction,
+  propertyName: string,
+): RelationMetadataArgs | undefined {
+  return getMetadataArgsStorage().relations.find(
+    (relation: RelationMetadataArgs) => {
+      return (
+        relation.target === target && relation.propertyName === propertyName
+      );
+    },
+  );
+}
+
+function relationTarget(
+  relation: RelationMetadataArgs | undefined,
+): GenericFunction | undefined {
+  const type: unknown = relation?.type;
+  if (typeof type === "function" && type.prototype === undefined) {
+    return (type as () => GenericFunction)();
+  }
+  return type as GenericFunction | undefined;
+}
+
+describe("NetworkSite self-nesting hierarchy", () => {
+  test("parentSite is an Entity relation back to NetworkSite", () => {
+    const metadata: TableColumnMetadata =
+      new NetworkSite().getTableColumnMetadata("parentSite");
+
+    expect(metadata).toBeDefined();
+    expect(metadata.type).toBe(TableColumnType.Entity);
+    expect(metadata.modelType).toBe(NetworkSite);
+    expect(metadata.manyToOneRelationColumn).toBe("parentSiteId");
+  });
+
+  test("parentSite FK resolves to NetworkSite and orphans children with SET NULL", () => {
+    const relation: RelationMetadataArgs | undefined = relationArgs(
+      NetworkSite,
+      "parentSite",
+    );
+
+    expect(relation).toBeDefined();
+    expect(relationTarget(relation)).toBe(NetworkSite);
+    expect(relation?.options.onDelete).toBe("SET NULL");
+  });
+
+  test("NetworkDevice.site relation targets NetworkSite with SET NULL", () => {
+    const metadata: TableColumnMetadata =
+      new NetworkDevice().getTableColumnMetadata("site");
+
+    expect(metadata.modelType).toBe(NetworkSite);
+    expect(metadata.manyToOneRelationColumn).toBe("siteId");
+
+    const relation: RelationMetadataArgs | undefined = relationArgs(
+      NetworkDevice,
+      "site",
+    );
+    expect(relationTarget(relation)).toBe(NetworkSite);
+    expect(relation?.options.onDelete).toBe("SET NULL");
+  });
+
+  test("child rows die with their site: CASCADE from timeline, link and rule", () => {
+    expect(
+      relationArgs(NetworkSiteStatusTimeline, "site")?.options.onDelete,
+    ).toBe("CASCADE");
+    expect(relationArgs(NetworkSiteLink, "fromSite")?.options.onDelete).toBe(
+      "CASCADE",
+    );
+    expect(relationArgs(NetworkSiteLink, "toSite")?.options.onDelete).toBe(
+      "CASCADE",
+    );
+    expect(
+      relationArgs(NetworkSiteAssignmentRule, "site")?.options.onDelete,
+    ).toBe("CASCADE");
+  });
+
+  test("endpoints detach from sites (SET NULL) but die with their device (CASCADE)", () => {
+    expect(relationArgs(NetworkEndpoint, "site")?.options.onDelete).toBe(
+      "SET NULL",
+    );
+    expect(
+      relationArgs(NetworkEndpoint, "attachedNetworkDevice")?.options.onDelete,
+    ).toBe("CASCADE");
+  });
+
+  test("endpoints are unique per MAC per project", () => {
+    expect(getUniqueColumnBy(new NetworkEndpoint(), "macAddress")).toBe(
+      "projectId",
+    );
+  });
+
+  test("crud api routes are registered", () => {
+    expect(new NetworkSite().getCrudApiPath()?.toString()).toBe(
+      "/network-site",
+    );
+    expect(new NetworkEndpoint().getCrudApiPath()?.toString()).toBe(
+      "/network-endpoint",
+    );
+    expect(new NetworkSiteStatusTimeline().getCrudApiPath()?.toString()).toBe(
+      "/network-site-status-timeline",
+    );
+    expect(new NetworkSiteLink().getCrudApiPath()?.toString()).toBe(
+      "/network-site-link",
+    );
+    expect(new NetworkSiteAssignmentRule().getCrudApiPath()?.toString()).toBe(
+      "/network-site-assignment-rule",
+    );
+  });
+});

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

@@ -11,11 +11,15 @@ import AnalyticsTableEngine from "../../../Types/AnalyticsDatabase/AnalyticsTabl
 import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import GenericObject from "../../../Types/GenericObject";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import ModelPermission from "../../../Server/Types/AnalyticsDatabase/ModelPermission";
 import {
   describe,
   expect,
@@ -417,6 +421,98 @@ describe("AnalyticsDatabaseService", () => {
       // A grouped query never needs the empty-window guard.
       expect(query).not.toContain("HAVING count() > 0");
     });
+
+    test("table-qualifies WHERE references so SELECT aliases cannot capture them", () => {
+      /*
+       * Regression for the Kubernetes Costs page 500: under Total the
+       * timestamp is selected as `min(col) as col`, and ClickHouse
+       * substitutes that alias into same-level unqualified WHERE
+       * references — `WHERE col >= ...` became
+       * `WHERE min(col) >= ...` (ILLEGAL_AGGREGATION). Qualified
+       * references (`table.col`) always resolve to the real column.
+       */
+      const result: { statement: Statement; columns: Array<string> } =
+        service.toAggregateStatement(
+          makeBaseAggregateBy({
+            aggregationInterval: "Total",
+            groupBy: { column_1: true },
+            query: { column_1: "<cluster>" },
+          }),
+        );
+      const query: string = result.statement.query;
+
+      expect(query).toContain("min(column_ObjectID) as column_ObjectID");
+      expect(query).toMatch(
+        /AND \{p\d+_t:Identifier\}\.\{p\d+_c:Identifier\} = \{p\d+:String\}/,
+      );
+
+      const params: Record<string, unknown> = result.statement.query_params;
+      const qualifierEntries: Array<[string, unknown]> = Object.entries(
+        params,
+      ).filter(([key]: [string, unknown]) => {
+        return key.endsWith("_t");
+      });
+      expect(qualifierEntries).toHaveLength(1);
+      expect(qualifierEntries[0]![1]).toBe("<table-name>");
+    });
+
+    test("bucketed queries qualify the window filter so it reads raw timestamps", () => {
+      /*
+       * Before qualification the bucket alias (`date_trunc(...) as col`)
+       * was substituted into WHERE, silently snapping the window edges
+       * to bucket boundaries. The filter must read the real column.
+       */
+      const result: { statement: Statement; columns: Array<string> } =
+        service.toAggregateStatement(
+          makeBaseAggregateBy({
+            query: {
+              column_ObjectID: new InBetween(
+                new Date("2024-01-01"),
+                new Date("2024-01-02"),
+              ),
+            },
+          }),
+        );
+      const query: string = result.statement.query;
+
+      expect(query).toContain("toStartOfInterval(column_ObjectID");
+      // Both InBetween bounds reference the qualified real column.
+      expect(query).toMatch(
+        /AND \{p\d+_t:Identifier\}\.\{p\d+_c:Identifier\} >= \{p\d+:String\} AND \{p\d+_t:Identifier\}\.\{p\d+_c:Identifier\} <= \{p\d+:String\}/,
+      );
+      // The GROUP BY / ORDER BY keep targeting the bare bucket alias.
+      expect(query).toContain("GROUP BY column_ObjectID");
+
+      const qualifiers: Array<unknown> = Object.entries(
+        result.statement.query_params,
+      )
+        .filter(([key]: [string, unknown]) => {
+          return key.endsWith("_t");
+        })
+        .map(([, value]: [string, unknown]) => {
+          return value;
+        });
+      expect(qualifiers).toStrictEqual(["<table-name>", "<table-name>"]);
+    });
+
+    test("filters on the aggregated measure column stay on the real column", () => {
+      /*
+       * `sum(column_2) as column_2` shadows the measure column too — a
+       * WHERE on it would otherwise also become an aggregate reference.
+       */
+      const result: { statement: Statement; columns: Array<string> } =
+        service.toAggregateStatement(
+          makeBaseAggregateBy({
+            query: { column_2: new GreaterThan(5) },
+          }),
+        );
+      const query: string = result.statement.query;
+
+      expect(query).toContain("sum(column_2) as column_2");
+      expect(query).toMatch(
+        /AND \{p\d+_t:Identifier\}\.\{p\d+_c:Identifier\} > \{p\d+:Int32\}/,
+      );
+    });
   });
 
   describe("toDeleteStatement", () => {
@@ -619,6 +715,149 @@ describe("AnalyticsDatabaseService", () => {
     });
   });
 
+  /*
+   * countBy parses the count() aggregate out of ClickHouse's JSON response.
+   * Whether that UInt64 arrives as a JSON string or a JSON number depends on
+   * the server's output_format_json_quote_64bit_integers setting — quoted
+   * (string) was the default until ClickHouse 25.x flipped it to numbers.
+   * A string-only typeof check silently read every count as 0 on modern
+   * servers, which made telemetry monitors (Logs / Traces / Exceptions)
+   * never meet their count-threshold criteria — monitors stuck "Operational"
+   * forever. These tests pin the parsing for both wire formats and every
+   * degraded-response shape.
+   */
+  describe("countBy result parsing", () => {
+    let checkReadPermissionMock: jest.Mock;
+
+    const mockCountResponse: (response: unknown) => void = (
+      response: unknown,
+    ): void => {
+      jest.spyOn(service, "executeQuery").mockResolvedValue({
+        json: () => {
+          return Promise.resolve(response);
+        },
+      } as never);
+    };
+
+    beforeEach(() => {
+      checkReadPermissionMock = jest
+        .spyOn(ModelPermission, "checkReadPermission")
+        .mockImplementation((_modelType: unknown, query: unknown) => {
+          return Promise.resolve({
+            query,
+            select: null,
+          } as never);
+        }) as unknown as jest.Mock;
+      jest.spyOn(logger, "debug").mockImplementation(() => {
+        return undefined!;
+      });
+      jest.spyOn(logger, "warn").mockImplementation(() => {
+        return undefined!;
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    const countBy: () => Promise<number> = async (): Promise<number> => {
+      const result: PositiveNumber = await service.countBy({
+        query: {},
+        props: { isRoot: true },
+      });
+      return result.toNumber();
+    };
+
+    test("parses count returned as a JSON number (ClickHouse >= 25.x default)", async () => {
+      mockCountResponse({ data: [{ count: 42 }] });
+      expect(await countBy()).toBe(42);
+    });
+
+    test("parses count returned as a JSON string (quoted 64-bit integers)", async () => {
+      mockCountResponse({ data: [{ count: "42" }] });
+      expect(await countBy()).toBe(42);
+    });
+
+    test("parses a numeric zero count as 0", async () => {
+      mockCountResponse({ data: [{ count: 0 }] });
+      expect(await countBy()).toBe(0);
+    });
+
+    test("parses a string zero count as 0", async () => {
+      mockCountResponse({ data: [{ count: "0" }] });
+      expect(await countBy()).toBe(0);
+    });
+
+    test("parses a count of 1 — the smallest value that can cross a monitor threshold", async () => {
+      // The default log-monitor offline criteria is "Log Count >= 1".
+      mockCountResponse({ data: [{ count: 1 }] });
+      expect(await countBy()).toBe(1);
+    });
+
+    test("parses a large count", async () => {
+      mockCountResponse({ data: [{ count: "6718284" }] });
+      expect(await countBy()).toBe(6718284);
+    });
+
+    test("defaults to 0 when the response has no data field", async () => {
+      mockCountResponse({});
+      expect(await countBy()).toBe(0);
+    });
+
+    test("defaults to 0 when the data array is empty", async () => {
+      mockCountResponse({ data: [] });
+      expect(await countBy()).toBe(0);
+    });
+
+    test("defaults to 0 when the row has no count key", async () => {
+      mockCountResponse({ data: [{ other: 5 }] });
+      expect(await countBy()).toBe(0);
+    });
+
+    test("defaults to 0 when the count value is null", async () => {
+      mockCountResponse({ data: [{ count: null }] });
+      expect(await countBy()).toBe(0);
+    });
+
+    test("defaults to 0 (with a warning) when the response body is unparseable", async () => {
+      /*
+       * timeout_overflow_mode='break' can truncate a count() response —
+       * json() then rejects. countBy must degrade to 0, not throw.
+       */
+      jest.spyOn(service, "executeQuery").mockResolvedValue({
+        json: () => {
+          return Promise.reject(new Error("truncated response"));
+        },
+      } as never);
+      expect(await countBy()).toBe(0);
+      expect(logger.warn).toHaveBeenCalled();
+    });
+
+    test("uses the permission-checked query for the count statement", async () => {
+      mockCountResponse({ data: [{ count: 7 }] });
+
+      // Must be a real model column: the where-statement compiler rejects unknown keys.
+      const rewrittenQuery: GenericObject = { column_1: "tenant-scoped" };
+      checkReadPermissionMock.mockImplementation(() => {
+        return Promise.resolve({
+          query: rewrittenQuery,
+          select: null,
+        } as never);
+      });
+
+      const toCountStatementSpy: jest.Mock = jest.spyOn(
+        service,
+        "toCountStatement",
+      ) as unknown as jest.Mock;
+
+      await countBy();
+
+      expect(toCountStatementSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ query: rewrittenQuery }),
+      );
+    });
+  });
+
   describe("execute / executeQuery per-call options", () => {
     let exec: ReturnType<typeof jest.fn>;
     let query: ReturnType<typeof jest.fn>;