@oneuptime/common 11.7.2 → 11.7.3

package/Models/AnalyticsModels/KubernetesCostAllocation.ts

@@ -348,6 +348,12 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
           title: "CPU Core Usage Average",
           description: "Average CPU cores actually used over the window.",
         },
+        {
+          key: "cpuCoreLimitAverage",
+          title: "CPU Core Limit Average",
+          description:
+            "Average CPU core limit over the window. 0 when no limit is set — which is also what a row ingested before this column reads back.",
+        },
         {
           key: "cpuCost",
           title: "CPU Cost",
@@ -378,6 +384,18 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
           title: "RAM Bytes Usage Average",
           description: "Average RAM bytes actually used over the window.",
         },
+        {
+          key: "ramBytesLimitAverage",
+          title: "RAM Bytes Limit Average",
+          description:
+            "Average RAM byte limit over the window. 0 when no limit is set — which is also what a row ingested before this column reads back.",
+        },
+        {
+          key: "ramBytesUsageMax",
+          title: "RAM Bytes Usage Max",
+          description:
+            "Peak RAM bytes used during the window, from Prometheus rather than the cost engine — the engine only reports averages, and an hourly mean hides the burst that OOMKills a container. 0 when the agent has no Prometheus configured, when the scrape had no data, or on rows ingested before this column; treat 0 as 'unknown', never as a real peak.",
+        },
         {
           key: "ramCost",
           title: "RAM Cost",
@@ -472,6 +490,49 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
       },
     });
 
+    /*
+     * Delivery bookkeeping, not workload data. A window wider than the
+     * agent's batch size arrives as several independent ingest jobs, so the
+     * ingest service needs to tell "another chunk of the delivery I am
+     * already ingesting" (accept) from "a window a previous delivery already
+     * ingested" (drop, or a restarted agent double-counts spend). shipmentId
+     * is the agent's content hash of the window — identical across restarts,
+     * different when the engine's answer for that window changed.
+     *
+     * Empty / 0 on rows written before these columns existed and on rows
+     * from agents older than the shipment contract; the ingest service falls
+     * back to the whole-window guard for those.
+     */
+    const shipmentIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "shipmentId",
+      title: "Shipment ID",
+      description:
+        "Content hash identifying the agent delivery this row arrived in. Used to deduplicate re-shipped windows; empty for rows ingested before the shipment contract.",
+      required: true,
+      defaultValue: "",
+      type: TableColumnType.Text,
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const shipmentChunkColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "shipmentChunk",
+      title: "Shipment Chunk",
+      description:
+        "Index of the request within its shipment that carried this row. 0 for single-request shipments and for rows ingested before the shipment contract.",
+      required: true,
+      defaultValue: 0,
+      type: TableColumnType.Number,
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
     const retentionDateColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
       key: "retentionDate",
       codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
@@ -517,6 +578,8 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
         labelKeysColumn,
         ...measureColumns,
         currencyColumn,
+        shipmentIdColumn,
+        shipmentChunkColumn,
         retentionDateColumn,
       ],
       sortKeys: [
@@ -688,6 +751,14 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
     this.setColumnValue("cpuCoreUsageAverage", v);
   }
 
+  public get cpuCoreLimitAverage(): number | undefined {
+    return this.getColumnValue("cpuCoreLimitAverage") as number | undefined;
+  }
+
+  public set cpuCoreLimitAverage(v: number | undefined) {
+    this.setColumnValue("cpuCoreLimitAverage", v);
+  }
+
   public get cpuCost(): number | undefined {
     return this.getColumnValue("cpuCost") as number | undefined;
   }
@@ -736,6 +807,22 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
     this.setColumnValue("ramBytesUsageAverage", v);
   }
 
+  public get ramBytesLimitAverage(): number | undefined {
+    return this.getColumnValue("ramBytesLimitAverage") as number | undefined;
+  }
+
+  public set ramBytesLimitAverage(v: number | undefined) {
+    this.setColumnValue("ramBytesLimitAverage", v);
+  }
+
+  public get ramBytesUsageMax(): number | undefined {
+    return this.getColumnValue("ramBytesUsageMax") as number | undefined;
+  }
+
+  public set ramBytesUsageMax(v: number | undefined) {
+    this.setColumnValue("ramBytesUsageMax", v);
+  }
+
   public get ramCost(): number | undefined {
     return this.getColumnValue("ramCost") as number | undefined;
   }
@@ -832,6 +919,22 @@ export default class KubernetesCostAllocation extends AnalyticsBaseModel {
     this.setColumnValue("currency", v);
   }
 
+  public get shipmentId(): string | undefined {
+    return this.getColumnValue("shipmentId") as string | undefined;
+  }
+
+  public set shipmentId(v: string | undefined) {
+    this.setColumnValue("shipmentId", v);
+  }
+
+  public get shipmentChunk(): number | undefined {
+    return this.getColumnValue("shipmentChunk") as number | undefined;
+  }
+
+  public set shipmentChunk(v: number | undefined) {
+    this.setColumnValue("shipmentChunk", v);
+  }
+
   public get retentionDate(): Date | undefined {
     return this.getColumnValue("retentionDate") as Date | undefined;
   }

package/Models/DatabaseModels/TableView.ts

@@ -555,4 +555,44 @@ export default class TableView extends BaseModel {
     nullable: true,
   })
   public facets?: JSONObject = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTableView,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadTableView,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTableView,
+    ],
+  })
+  @TableColumn({
+    title: "Columns",
+    required: false,
+    unique: false,
+    type: TableColumnType.JSON,
+    canReadOnRelationQuery: true,
+    description:
+      "Which columns are shown, and in what order, for this table view",
+    example:
+      '{"order": ["name", "currentMonitorStatus"], "hidden": ["labels"]}',
+  })
+  @Column({
+    type: ColumnType.JSON,
+    unique: false,
+    nullable: true,
+  })
+  public columns?: JSONObject = undefined;
 }

package/Server/Infrastructure/Postgres/SchemaMigrations/1785241000000-AddColumnsToTableView.ts

@@ -0,0 +1,13 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddColumnsToTableView1785241000000 implements MigrationInterface {
+  public name: string = "AddColumnsToTableView1785241000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "TableView" ADD "columns" jsonb`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "TableView" DROP COLUMN "columns"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -473,6 +473,7 @@ import { MigrationName1785066759532 } from "./1785066759532-MigrationName";
 import { AddHotQueryIndexes1785140242697 } from "./1785140242697-AddHotQueryIndexes";
 import { AddHotQueryIndexesSecondPass1785148065137 } from "./1785148065137-AddHotQueryIndexesSecondPass";
 import { RepairCrossProjectMonitorStatusReferences1785240000000 } from "./1785240000000-RepairCrossProjectMonitorStatusReferences";
+import { AddColumnsToTableView1785241000000 } from "./1785241000000-AddColumnsToTableView";
 
 export default [
   InitialMigration,
@@ -950,4 +951,5 @@ export default [
   AddHotQueryIndexes1785140242697,
   AddHotQueryIndexesSecondPass1785148065137,
   RepairCrossProjectMonitorStatusReferences1785240000000,
+  AddColumnsToTableView1785241000000,
 ];

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

@@ -37,12 +37,15 @@ describe("Analytics KubernetesCostAllocation model", () => {
       "cpuCoreHours",
       "cpuCoreRequestAverage",
       "cpuCoreUsageAverage",
+      "cpuCoreLimitAverage",
       "cpuCost",
       "gpuHours",
       "gpuCost",
       "ramByteHours",
       "ramBytesRequestAverage",
       "ramBytesUsageAverage",
+      "ramBytesLimitAverage",
+      "ramBytesUsageMax",
       "ramCost",
       "pvByteHours",
       "pvCost",
@@ -95,6 +98,19 @@ describe("Analytics KubernetesCostAllocation model", () => {
     );
   });
 
+  test("carries the shipment identity the ingest dedup relies on", () => {
+    const shipmentId: AnalyticsTableColumn | null =
+      model.getTableColumn("shipmentId");
+    expect(shipmentId?.type).toBe(TableColumnType.Text);
+    // Rows written before the shipment contract read back as "no identity".
+    expect(shipmentId?.defaultValue).toBe("");
+
+    const shipmentChunk: AnalyticsTableColumn | null =
+      model.getTableColumn("shipmentChunk");
+    expect(shipmentChunk?.type).toBe(TableColumnType.Number);
+    expect(shipmentChunk?.defaultValue).toBe(0);
+  });
+
   test("stores labels as a map with an extracted key column", () => {
     const labels: AnalyticsTableColumn | null = model.getTableColumn("labels");
     expect(labels?.type).toBe(TableColumnType.MapStringString);

package/Tests/Types/JSONFunctions.test.ts

@@ -1,4 +1,4 @@
-import { JSONArray, JSONObject } from "../../Types/JSON";
+import { JSONArray, JSONObject, ObjectType } from "../../Types/JSON";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import JSONFunctions from "../../Types/JSONFunctions";
 
@@ -262,4 +262,106 @@ describe("JSONFunctions Class", () => {
       expect(size).toBeGreaterThanOrEqual(0);
     });
   });
+
+  describe("serialize and serializeArray Methods", () => {
+    test("Passes primitives and null through, and drops undefined keys", () => {
+      const input: JSONObject = {
+        n: 1,
+        s: "x",
+        b: true,
+        nil: null,
+        gone: undefined,
+      };
+      expect(JSONFunctions.serialize(input)).toEqual({
+        n: 1,
+        s: "x",
+        b: true,
+        nil: null,
+      });
+    });
+
+    test("Tags a Date value with its DateTime object type", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        when: new Date("2023-01-01T00:00:00.000Z"),
+      });
+      const when: JSONObject = serialized["when"] as JSONObject;
+      expect(when["_type"]).toBe(ObjectType.DateTime);
+      expect(typeof when["value"]).toBe("string");
+    });
+
+    test("Serializes nested objects recursively", () => {
+      expect(JSONFunctions.serialize({ a: { b: 2 } })).toEqual({ a: { b: 2 } });
+    });
+
+    test("Serializes each value inside an array", () => {
+      expect(JSONFunctions.serialize({ arr: [1, "x", null] })).toEqual({
+        arr: [1, "x", null],
+      });
+    });
+
+    test("serializeArray serializes each object in the array", () => {
+      const input: JSONArray = [{ a: 1 }, { b: 2 }];
+      expect(JSONFunctions.serializeArray(input)).toEqual([{ a: 1 }, { b: 2 }]);
+    });
+  });
+
+  describe("deserialize and deserializeArray Methods", () => {
+    test("Passes primitives and null through", () => {
+      const input: JSONObject = { n: 1, s: "x", nil: null };
+      expect(JSONFunctions.deserialize(input)).toEqual({
+        n: 1,
+        s: "x",
+        nil: null,
+      });
+    });
+
+    test("Rebuilds a Buffer-tagged value into a Buffer", () => {
+      const input: JSONObject = {
+        payload: {
+          _type: ObjectType.Buffer,
+          value: { type: ObjectType.Buffer, data: [1, 2, 3] },
+        },
+      };
+      const deserialized: JSONObject = JSONFunctions.deserialize(input);
+      expect(Buffer.isBuffer(deserialized["payload"])).toBe(true);
+      expect(deserialized["payload"]).toEqual(Buffer.from([1, 2, 3]));
+    });
+
+    test("deserializeArray deserializes each object in the array", () => {
+      const input: JSONArray = [{ a: 1 }, { b: 2 }];
+      expect(JSONFunctions.deserializeArray(input)).toEqual([
+        { a: 1 },
+        { b: 2 },
+      ]);
+    });
+  });
+
+  describe("serializeValue and deserializeValue Methods", () => {
+    test("Pass numbers and non-empty strings through unchanged", () => {
+      expect(JSONFunctions.serializeValue(5)).toBe(5);
+      expect(JSONFunctions.serializeValue("hi")).toBe("hi");
+      expect(JSONFunctions.deserializeValue(5)).toBe(5);
+      expect(JSONFunctions.deserializeValue("hi")).toBe("hi");
+    });
+
+    test("Pass null through unchanged", () => {
+      expect(JSONFunctions.serializeValue(null)).toBeNull();
+      expect(JSONFunctions.deserializeValue(null)).toBeNull();
+    });
+  });
+
+  describe("serialize and deserialize round trip", () => {
+    test("A plain object survives a serialize -> JSON -> deserialize round trip", () => {
+      const original: JSONObject = {
+        a: 1,
+        b: "x",
+        c: { d: 2 },
+        e: [1, 2, 3],
+      };
+      const roundTripped: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(JSON.stringify(JSONFunctions.serialize(original))),
+      );
+      expect(roundTripped).toEqual(original);
+    });
+  });
 });