@oneuptime/common 11.6.2 → 11.7.0

package/Models/AnalyticsModels/SloHistory.ts

@@ -42,8 +42,11 @@ import Permission from "../../Types/Permission";
  * dashboard charts do) or dedupe explicitly via
  * `argMax(value, version) ... GROUP BY <identity>`.
  *
- * `metricName` values: "sli.percent", "error.budget.remaining.percent",
- * "burn.rate", "good.count", "total.count".
+ * `metricName` values written today: "sli.percent",
+ * "error.budget.remaining.percent" and "burn.rate" — the three gauges the
+ * evaluation worker persists per run. "good.count" / "total.count" are
+ * reserved for event-based (Metric) SLIs, which the worker does not
+ * evaluate yet; nothing writes or reads them.
  */
 export default class SloHistory extends AnalyticsBaseModel {
   public constructor() {
@@ -87,7 +90,7 @@ export default class SloHistory extends AnalyticsBaseModel {
       isLowCardinality: true,
       title: "Metric Name",
       description:
-        "Which SLO series this row belongs to: sli.percent, error.budget.remaining.percent, burn.rate, good.count, or total.count.",
+        "Which SLO series this row belongs to: sli.percent, error.budget.remaining.percent, or burn.rate.",
       required: true,
       type: TableColumnType.Text,
       accessControl: {

package/Models/DatabaseModels/ServiceLevelObjective.ts

@@ -12,6 +12,7 @@ import AccessControlColumn from "../../Types/Database/AccessControlColumn";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
 import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableAuditLog from "../../Types/Database/EnableAuditLog";
 import EnableDocumentation from "../../Types/Database/EnableDocumentation";
 import EnableWorkflow from "../../Types/Database/EnableWorkflow";
 import SlugifyColumn from "../../Types/Database/SlugifyColumn";
@@ -72,6 +73,14 @@ const decimalTransformer: ValueTransformer = {
  * an owner of the SLO they just created).
  */
 @OperationalResource()
+/*
+ * An SLO's target, window and monitor set are the definition of what
+ * "reliable enough" means for a service, so a change to any of them
+ * silently rewrites history: budgets recompute against the new
+ * definition on the worker's next tick. Recording those edits is how a
+ * team answers "did the SLO get better, or did someone move the target?".
+ */
+@EnableAuditLog()
 @EnableDocumentation()
 @AccessControlColumn("labels")
 @TenantColumn("projectId")

package/Server/Infrastructure/Postgres/SchemaMigrations/1785066759532-MigrationName.ts

@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1785066759532 implements MigrationInterface {
+  public name = "MigrationName1785066759532";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * 1784200000000 added these two as `text`, but the entity declares them
+     * ColumnType.LongText, which maps to `varchar`. The generator wants to
+     * DROP and re-ADD the columns; an in-place TYPE change reaches the same
+     * schema without discarding the SNMP v3 credentials already stored on
+     * existing discovery scans.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3AuthKey" TYPE character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3PrivKey" TYPE character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3PrivKey" TYPE text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3AuthKey" TYPE text`,
+    );
+  }
+}

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

@@ -469,6 +469,7 @@ import { AddNetworkSiteAlerting1784897317860 } from "./1784897317860-AddNetworkS
 import { AddNetworkDevicePollingColumns1784970388777 } from "./1784970388777-AddNetworkDevicePollingColumns";
 import { AddNetworkSiteTypeTable1784986826214 } from "./1784986826214-AddNetworkSiteTypeTable";
 import { AddServiceLevelObjective1784987015619 } from "./1784987015619-AddServiceLevelObjective";
+import { MigrationName1785066759532 } from "./1785066759532-MigrationName";
 
 export default [
   InitialMigration,
@@ -942,4 +943,5 @@ export default [
   AddNetworkDevicePollingColumns1784970388777,
   AddNetworkSiteTypeTable1784986826214,
   AddServiceLevelObjective1784987015619,
+  MigrationName1785066759532,
 ];

package/Server/Services/ServiceLevelObjectiveService.ts

@@ -650,8 +650,15 @@ export class Service extends DatabaseService<Model> {
   private validateWindowDays(value: unknown): number {
     const windowDays: number = this.normalizeNumericInput(value);
 
-    if (!Number.isFinite(windowDays) || windowDays < 1 || windowDays > 366) {
-      throw new BadDataException("SLO window must be between 1 and 366 days.");
+    /*
+     * The column is a Postgres integer, so a decimal that cleared only the
+     * range check would fail the INSERT with a raw driver error instead of
+     * this message.
+     */
+    if (!Number.isInteger(windowDays) || windowDays < 1 || windowDays > 366) {
+      throw new BadDataException(
+        "SLO window must be a whole number of days between 1 and 366.",
+      );
     }
 
     return windowDays;
@@ -660,13 +667,14 @@ export class Service extends DatabaseService<Model> {
   private validateAtRiskThresholdPercentage(value: unknown): number {
     const atRiskThresholdPercentage: number = this.normalizeNumericInput(value);
 
+    // Integer column — see validateWindowDays.
     if (
-      !Number.isFinite(atRiskThresholdPercentage) ||
+      !Number.isInteger(atRiskThresholdPercentage) ||
       atRiskThresholdPercentage < 0 ||
       atRiskThresholdPercentage > 100
     ) {
       throw new BadDataException(
-        "SLO at-risk threshold must be a percentage between 0 and 100.",
+        "SLO at-risk threshold must be a whole percentage between 0 and 100.",
       );
     }
 

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

@@ -62,9 +62,9 @@ const RESOLVED_STATE_ID: ObjectID = new ObjectID(
 const TARGET_PERCENTAGE_ERROR_MESSAGE: string =
   "SLO target must be greater than 0 and at most 99.999. A 100% target leaves no error budget.";
 const WINDOW_DAYS_ERROR_MESSAGE: string =
-  "SLO window must be between 1 and 366 days.";
+  "SLO window must be a whole number of days between 1 and 366.";
 const AT_RISK_THRESHOLD_ERROR_MESSAGE: string =
-  "SLO at-risk threshold must be a percentage between 0 and 100.";
+  "SLO at-risk threshold must be a whole percentage between 0 and 100.";
 
 /*
  * Every column getDueSlos must hand to the evaluation worker. Enumerated here

package/Tests/Types/Monitor/MonitorCriteria.test.ts

@@ -0,0 +1,155 @@
+import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * MonitorCriteria wraps the ordered list of MonitorCriteriaInstance that a
+ * monitor step evaluates. These tests lock in the default builder (which
+ * composes the online + offline instances), the validation contract (which
+ * delegates to each instance), and the toJSON/fromJSON round-trip.
+ */
+
+const DEFAULT_ARG: {
+  monitorType: MonitorType;
+  monitorName: string;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+} = {
+  monitorType: MonitorType.Ping,
+  monitorName: "Gateway",
+  onlineMonitorStatusId: new ObjectID("100000000000000000000011"),
+  offlineMonitorStatusId: new ObjectID("100000000000000000000012"),
+  defaultIncidentSeverityId: new ObjectID("100000000000000000000013"),
+  defaultAlertSeverityId: new ObjectID("100000000000000000000014"),
+};
+
+describe("MonitorCriteria", () => {
+  describe("getDefaultMonitorCriteria", () => {
+    test("composes both an offline and an online instance for Ping", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+
+      // Ping has both an offline (Disallow) and an online criteria instance.
+      expect(criteria.data?.monitorCriteriaInstanceArray).toHaveLength(2);
+      for (const instance of criteria.data!.monitorCriteriaInstanceArray) {
+        expect(instance).toBeInstanceOf(MonitorCriteriaInstance);
+      }
+    });
+
+    test("the default Ping criteria passes validation", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBeNull();
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("errors when data is missing", () => {
+      const criteria: MonitorCriteria = new MonitorCriteria();
+      criteria.data = undefined;
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBe("Monitor Criteria is required");
+    });
+
+    test("errors when the instance array is empty", () => {
+      const criteria: MonitorCriteria = new MonitorCriteria();
+      criteria.data = { monitorCriteriaInstanceArray: [] };
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBe("Monitor Criteria is required");
+    });
+
+    test("propagates a validation error from a contained instance", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      // Corrupt a contained instance: strip its required name.
+      criteria.data!.monitorCriteriaInstanceArray[0]!.data!.name = "";
+      const error: string | null = MonitorCriteria.getValidationError(
+        criteria,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Name is required");
+    });
+  });
+
+  describe("getNewMonitorCriteriaAsJSON", () => {
+    test("wraps a single default instance", () => {
+      const json: JSONObject = MonitorCriteria.getNewMonitorCriteriaAsJSON();
+      expect(json["_type"]).toBe("MonitorCriteria");
+      const value: JSONObject = json["value"] as JSONObject;
+      expect(Array.isArray(value["monitorCriteriaInstanceArray"])).toBe(true);
+      expect(
+        (value["monitorCriteriaInstanceArray"] as Array<unknown>).length,
+      ).toBe(1);
+    });
+  });
+
+  describe("toJSON / fromJSON round-trip", () => {
+    test("serializes with the MonitorCriteria type wrapper", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const json: JSONObject = criteria.toJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorCriteria);
+    });
+
+    test("round-trips the instance count", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const restored: MonitorCriteria = MonitorCriteria.fromJSON(
+        criteria.toJSON(),
+      );
+      expect(restored.data?.monitorCriteriaInstanceArray).toHaveLength(2);
+      expect(restored.data?.monitorCriteriaInstanceArray[0]).toBeInstanceOf(
+        MonitorCriteriaInstance,
+      );
+    });
+
+    test("toString returns a JSON string of the serialized value", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const parsed: JSONObject = JSON.parse(criteria.toString()) as JSONObject;
+      expect(parsed["_type"]).toBe(ObjectType.MonitorCriteria);
+    });
+  });
+
+  describe("fromJSON validation", () => {
+    test("returns the same instance when given a MonitorCriteria", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      expect(MonitorCriteria.fromJSON(criteria as unknown as JSONObject)).toBe(
+        criteria,
+      );
+    });
+
+    test("throws on a wrong _type", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({ _type: "Nope", value: {} });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when value is missing", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({
+          _type: ObjectType.MonitorCriteria,
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when monitorCriteriaInstanceArray is missing", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({
+          _type: ObjectType.MonitorCriteria,
+          value: {},
+        });
+      }).toThrow(BadDataException);
+    });
+  });
+});