@oneuptime/common 11.5.13 → 11.6.1

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

@@ -0,0 +1,289 @@
+import ExceptionInstance from "../../../Models/AnalyticsModels/ExceptionInstance";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import Search from "../../../Types/BaseDatabase/Search";
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStepExceptionMonitor, {
+  MonitorStepExceptionMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepExceptionMonitor";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("MonitorStepExceptionMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an empty monitor scoped to the last 60 seconds", () => {
+      const def: MonitorStepExceptionMonitor =
+        MonitorStepExceptionMonitorUtil.getDefault();
+
+      expect(def.telemetryServiceIds).toEqual([]);
+      expect(def.entityKeys).toEqual([]);
+      expect(def.exceptionTypes).toEqual([]);
+      expect(def.message).toBe("");
+      expect(def.includeResolved).toBe(false);
+      expect(def.includeArchived).toBe(false);
+      expect(def.lastXSecondsOfExceptions).toBe(60);
+    });
+  });
+
+  describe("toAnalyticsQuery", () => {
+    test("builds no filters for the empty default when the time window is off", () => {
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          lastXSecondsOfExceptions: 0,
+        });
+
+      expect(query).toEqual({});
+    });
+
+    test("scopes to telemetry services when provided", () => {
+      const serviceId: ObjectID = ObjectID.generate();
+
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          telemetryServiceIds: [serviceId],
+          lastXSecondsOfExceptions: 0,
+        });
+
+      expect(query.primaryEntityId).toBeInstanceOf(Includes);
+      expect((query.primaryEntityId as Includes).values).toEqual([serviceId]);
+    });
+
+    test("scopes to entity keys when provided", () => {
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          entityKeys: ["host-1", "pod-2"],
+          lastXSecondsOfExceptions: 0,
+        });
+
+      expect(query.entityKeys).toBeInstanceOf(Includes);
+      expect((query.entityKeys as Includes).values).toEqual([
+        "host-1",
+        "pod-2",
+      ]);
+    });
+
+    test("omits entity keys when the list is empty or undefined", () => {
+      expect(
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          entityKeys: [],
+          lastXSecondsOfExceptions: 0,
+        }).entityKeys,
+      ).toBeUndefined();
+
+      // Monitors saved before entityKeys existed carry it as undefined.
+      expect(
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          entityKeys: undefined,
+          lastXSecondsOfExceptions: 0,
+        }).entityKeys,
+      ).toBeUndefined();
+    });
+
+    test("filters by exception type when provided", () => {
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          exceptionTypes: ["TypeError", "ValueError"],
+          lastXSecondsOfExceptions: 0,
+        });
+
+      expect(query.exceptionType).toBeInstanceOf(Includes);
+      expect((query.exceptionType as Includes).values).toEqual([
+        "TypeError",
+        "ValueError",
+      ]);
+    });
+
+    test("omits the exception type filter when the list is empty", () => {
+      expect(
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          exceptionTypes: [],
+          lastXSecondsOfExceptions: 0,
+        }).exceptionType,
+      ).toBeUndefined();
+    });
+
+    test("searches the message when provided", () => {
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          message: "null pointer",
+          lastXSecondsOfExceptions: 0,
+        });
+
+      expect(query.message).toBeInstanceOf(Search);
+      expect((query.message as Search<string>).value).toBe("null pointer");
+    });
+
+    test("omits the message filter when it is an empty string", () => {
+      expect(
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          message: "",
+          lastXSecondsOfExceptions: 0,
+        }).message,
+      ).toBeUndefined();
+    });
+
+    test("builds a trailing time window from lastXSecondsOfExceptions", () => {
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          lastXSecondsOfExceptions: 300,
+        });
+
+      expect(query.time).toBeInstanceOf(InBetween);
+
+      const time: InBetween<Date> = query.time as InBetween<Date>;
+      const spanMs: number =
+        time.endValue.getTime() - time.startValue.getTime();
+
+      expect(Math.abs(spanMs - 300 * 1000)).toBeLessThan(2000);
+      expect(time.startValue.getTime()).toBeLessThan(time.endValue.getTime());
+    });
+
+    test("omits the time window when lastXSecondsOfExceptions is 0", () => {
+      expect(
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          lastXSecondsOfExceptions: 0,
+        }).time,
+      ).toBeUndefined();
+    });
+
+    test("does not encode includeResolved / includeArchived into the query", () => {
+      /*
+       * These flags are intentionally not part of the analytics query — the
+       * resolved/archived exclusion is applied by the telemetry monitor worker
+       * (see MonitorTelemetryMonitor), not here.
+       */
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          ...MonitorStepExceptionMonitorUtil.getDefault(),
+          includeResolved: true,
+          includeArchived: true,
+          lastXSecondsOfExceptions: 0,
+        });
+
+      expect(query).toEqual({});
+    });
+
+    test("combines every filter when all are set", () => {
+      const query: Query<ExceptionInstance> =
+        MonitorStepExceptionMonitorUtil.toAnalyticsQuery({
+          telemetryServiceIds: [ObjectID.generate()],
+          entityKeys: ["host-1"],
+          exceptionTypes: ["TypeError"],
+          message: "boom",
+          includeResolved: false,
+          includeArchived: false,
+          lastXSecondsOfExceptions: 60,
+        });
+
+      expect(query.primaryEntityId).toBeDefined();
+      expect(query.entityKeys).toBeDefined();
+      expect(query.exceptionType).toBeDefined();
+      expect(query.message).toBeDefined();
+      expect(query.time).toBeDefined();
+    });
+  });
+
+  describe("fromJSON", () => {
+    test("fills every field with a default when the JSON is empty", () => {
+      const monitor: MonitorStepExceptionMonitor =
+        MonitorStepExceptionMonitorUtil.fromJSON({});
+
+      expect(monitor.telemetryServiceIds).toEqual([]);
+      expect(monitor.entityKeys).toEqual([]);
+      expect(monitor.exceptionTypes).toEqual([]);
+      expect(monitor.message).toBe("");
+      expect(monitor.includeResolved).toBe(false);
+      expect(monitor.includeArchived).toBe(false);
+      expect(monitor.lastXSecondsOfExceptions).toBe(60);
+    });
+
+    test("coerces the include flags to booleans", () => {
+      const monitor: MonitorStepExceptionMonitor =
+        MonitorStepExceptionMonitorUtil.fromJSON({
+          includeResolved: true,
+          includeArchived: true,
+        });
+
+      expect(monitor.includeResolved).toBe(true);
+      expect(monitor.includeArchived).toBe(true);
+    });
+
+    test("falls back to 60 seconds for a zero/absent window", () => {
+      // `|| 60` means a stored 0 is treated as "unset" and becomes 60.
+      expect(
+        MonitorStepExceptionMonitorUtil.fromJSON({
+          lastXSecondsOfExceptions: 0,
+        }).lastXSecondsOfExceptions,
+      ).toBe(60);
+
+      expect(
+        MonitorStepExceptionMonitorUtil.fromJSON({
+          lastXSecondsOfExceptions: 120,
+        }).lastXSecondsOfExceptions,
+      ).toBe(120);
+    });
+  });
+
+  describe("toJSON / round trip", () => {
+    test("normalizes an undefined entityKeys to an empty array", () => {
+      const json: JSONObject = MonitorStepExceptionMonitorUtil.toJSON({
+        ...MonitorStepExceptionMonitorUtil.getDefault(),
+        entityKeys: undefined,
+      });
+
+      expect(json["entityKeys"]).toEqual([]);
+    });
+
+    test("round-trips a fully populated monitor", () => {
+      const original: MonitorStepExceptionMonitor = {
+        telemetryServiceIds: [ObjectID.generate()],
+        entityKeys: ["host-1"],
+        exceptionTypes: ["TypeError"],
+        message: "boom",
+        includeResolved: true,
+        includeArchived: true,
+        lastXSecondsOfExceptions: 300,
+      };
+
+      const roundTripped: MonitorStepExceptionMonitor =
+        MonitorStepExceptionMonitorUtil.fromJSON(
+          MonitorStepExceptionMonitorUtil.toJSON(original),
+        );
+
+      expect(roundTripped.entityKeys).toEqual(original.entityKeys);
+      expect(roundTripped.exceptionTypes).toEqual(original.exceptionTypes);
+      expect(roundTripped.message).toBe(original.message);
+      expect(roundTripped.includeResolved).toBe(original.includeResolved);
+      expect(roundTripped.includeArchived).toBe(original.includeArchived);
+      expect(roundTripped.lastXSecondsOfExceptions).toBe(
+        original.lastXSecondsOfExceptions,
+      );
+      expect(roundTripped.telemetryServiceIds.map(String)).toEqual(
+        original.telemetryServiceIds.map(String),
+      );
+    });
+
+    test("the default value round-trips unchanged", () => {
+      const def: MonitorStepExceptionMonitor =
+        MonitorStepExceptionMonitorUtil.getDefault();
+
+      const roundTripped: MonitorStepExceptionMonitor =
+        MonitorStepExceptionMonitorUtil.fromJSON(
+          MonitorStepExceptionMonitorUtil.toJSON(def),
+        );
+
+      expect(roundTripped).toEqual(def);
+    });
+  });
+});

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

@@ -0,0 +1,231 @@
+import Log from "../../../Models/AnalyticsModels/Log";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import Search from "../../../Types/BaseDatabase/Search";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import { JSONObject } from "../../../Types/JSON";
+import LogSeverity from "../../../Types/Log/LogSeverity";
+import MonitorStepLogMonitor, {
+  MonitorStepLogMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepLogMonitor";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("MonitorStepLogMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an empty monitor scoped to the last 60 seconds", () => {
+      const def: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+
+      expect(def.attributes).toEqual({});
+      expect(def.body).toBe("");
+      expect(def.severityTexts).toEqual([]);
+      expect(def.telemetryServiceIds).toEqual([]);
+      expect(def.entityKeys).toEqual([]);
+      expect(def.lastXSecondsOfLogs).toBe(60);
+    });
+  });
+
+  describe("toQuery", () => {
+    test("builds no filters for the empty default (other than the time window)", () => {
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        lastXSecondsOfLogs: 0, // disable the time window too
+      });
+
+      expect(query).toEqual({});
+    });
+
+    test("scopes to telemetry services when provided", () => {
+      const serviceId: ObjectID = ObjectID.generate();
+
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        telemetryServiceIds: [serviceId],
+        lastXSecondsOfLogs: 0,
+      });
+
+      expect(query.primaryEntityId).toBeInstanceOf(Includes);
+      expect((query.primaryEntityId as Includes).values).toEqual([serviceId]);
+    });
+
+    test("scopes to entity keys when provided", () => {
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        entityKeys: ["host-1", "pod-2"],
+        lastXSecondsOfLogs: 0,
+      });
+
+      expect(query.entityKeys).toBeInstanceOf(Includes);
+      expect((query.entityKeys as Includes).values).toEqual([
+        "host-1",
+        "pod-2",
+      ]);
+    });
+
+    test("omits entity keys when the list is empty or undefined", () => {
+      expect(
+        MonitorStepLogMonitorUtil.toQuery({
+          ...MonitorStepLogMonitorUtil.getDefault(),
+          entityKeys: [],
+          lastXSecondsOfLogs: 0,
+        }).entityKeys,
+      ).toBeUndefined();
+
+      expect(
+        MonitorStepLogMonitorUtil.toQuery({
+          ...MonitorStepLogMonitorUtil.getDefault(),
+          entityKeys: undefined,
+          lastXSecondsOfLogs: 0,
+        }).entityKeys,
+      ).toBeUndefined();
+    });
+
+    test("passes attributes through when non-empty", () => {
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        attributes: { env: "prod", retries: 3, ok: true },
+        lastXSecondsOfLogs: 0,
+      });
+
+      expect(query.attributes).toEqual({ env: "prod", retries: 3, ok: true });
+    });
+
+    test("omits attributes when the dictionary is empty", () => {
+      expect(
+        MonitorStepLogMonitorUtil.toQuery({
+          ...MonitorStepLogMonitorUtil.getDefault(),
+          attributes: {},
+          lastXSecondsOfLogs: 0,
+        }).attributes,
+      ).toBeUndefined();
+    });
+
+    test("filters by severity when provided", () => {
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        severityTexts: [LogSeverity.Error, LogSeverity.Fatal],
+        lastXSecondsOfLogs: 0,
+      });
+
+      expect(query.severityText).toBeInstanceOf(Includes);
+      expect((query.severityText as Includes).values).toEqual([
+        LogSeverity.Error,
+        LogSeverity.Fatal,
+      ]);
+    });
+
+    test("searches the body when a body filter is set", () => {
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        body: "connection refused",
+        lastXSecondsOfLogs: 0,
+      });
+
+      expect(query.body).toBeInstanceOf(Search);
+      expect((query.body as Search<string>).value).toBe("connection refused");
+    });
+
+    test("omits the body filter when it is an empty string", () => {
+      expect(
+        MonitorStepLogMonitorUtil.toQuery({
+          ...MonitorStepLogMonitorUtil.getDefault(),
+          body: "",
+          lastXSecondsOfLogs: 0,
+        }).body,
+      ).toBeUndefined();
+    });
+
+    test("builds a trailing time window from lastXSecondsOfLogs", () => {
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        lastXSecondsOfLogs: 120,
+      });
+
+      expect(query.time).toBeInstanceOf(InBetween);
+
+      const time: InBetween<Date> = query.time as InBetween<Date>;
+      const spanMs: number =
+        time.endValue.getTime() - time.startValue.getTime();
+
+      // 120 seconds back from now, within a small tolerance.
+      expect(Math.abs(spanMs - 120 * 1000)).toBeLessThan(2000);
+      expect(time.startValue.getTime()).toBeLessThan(time.endValue.getTime());
+    });
+
+    test("omits the time window when lastXSecondsOfLogs is 0", () => {
+      expect(
+        MonitorStepLogMonitorUtil.toQuery({
+          ...MonitorStepLogMonitorUtil.getDefault(),
+          lastXSecondsOfLogs: 0,
+        }).time,
+      ).toBeUndefined();
+    });
+
+    test("combines every filter when all are set", () => {
+      const serviceId: ObjectID = ObjectID.generate();
+
+      const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery({
+        attributes: { env: "prod" },
+        body: "timeout",
+        severityTexts: [LogSeverity.Error],
+        telemetryServiceIds: [serviceId],
+        entityKeys: ["host-1"],
+        lastXSecondsOfLogs: 60,
+      });
+
+      expect(query.primaryEntityId).toBeDefined();
+      expect(query.entityKeys).toBeDefined();
+      expect(query.attributes).toBeDefined();
+      expect(query.severityText).toBeDefined();
+      expect(query.body).toBeDefined();
+      expect(query.time).toBeDefined();
+    });
+  });
+
+  describe("toJSON / fromJSON", () => {
+    test("round-trips a fully populated monitor", () => {
+      const original: MonitorStepLogMonitor = {
+        attributes: { env: "prod", retries: 3 },
+        body: "timeout",
+        severityTexts: [LogSeverity.Error, LogSeverity.Warning],
+        telemetryServiceIds: [ObjectID.generate()],
+        entityKeys: ["host-1"],
+        lastXSecondsOfLogs: 300,
+      };
+
+      const roundTripped: MonitorStepLogMonitor =
+        MonitorStepLogMonitorUtil.fromJSON(
+          MonitorStepLogMonitorUtil.toJSON(original),
+        );
+
+      expect(roundTripped.attributes).toEqual(original.attributes);
+      expect(roundTripped.body).toBe(original.body);
+      expect(roundTripped.severityTexts).toEqual(original.severityTexts);
+      expect(roundTripped.entityKeys).toEqual(original.entityKeys);
+      expect(roundTripped.lastXSecondsOfLogs).toBe(original.lastXSecondsOfLogs);
+      expect(roundTripped.telemetryServiceIds.map(String)).toEqual(
+        original.telemetryServiceIds.map(String),
+      );
+    });
+
+    test("fromJSON defaults attributes and entityKeys when absent", () => {
+      const monitor: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.fromJSON(
+        {
+          telemetryServiceIds: [],
+        } as JSONObject,
+      );
+
+      expect(monitor.attributes).toEqual({});
+      // entityKeys is optional on older saved monitors — normalized to [].
+      expect(monitor.entityKeys).toEqual([]);
+    });
+
+    test("toJSON normalizes an undefined entityKeys to an empty array", () => {
+      const json: JSONObject = MonitorStepLogMonitorUtil.toJSON({
+        ...MonitorStepLogMonitorUtil.getDefault(),
+        entityKeys: undefined,
+      });
+
+      expect(json["entityKeys"]).toEqual([]);
+    });
+  });
+});