@oneuptime/common 11.7.3 → 11.7.4

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

@@ -0,0 +1,386 @@
+import { JSONObject } from "../../../Types/JSON";
+import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricsViewConfig from "../../../Types/Metrics/MetricsViewConfig";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorStepMetricMonitor, {
+  MonitorStepMetricMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import RollingTime from "../../../Types/RollingTime/RollingTime";
+
+/*
+ * Regression coverage for the blank-screen crash on the monitor view page.
+ *
+ * MetricMonitorPreview read `monitorStepMetricMonitor?.metricViewConfig.queryConfigs`.
+ * The optional chain stops at `monitorStepMetricMonitor`, so a step that HAS a
+ * metricMonitor but no metricViewConfig threw
+ *
+ *     TypeError: Cannot read properties of undefined (reading 'queryConfigs')
+ *
+ * during render. Nothing above it caught the throw, so React unmounted the whole
+ * tree and the dashboard went blank white — nav, sidebar and all.
+ *
+ * That shape is reachable because monitor steps are persisted as free-form JSON
+ * and rehydrated with a cast: nothing at runtime enforces that metricViewConfig
+ * is present. These tests lock in that resolving the config NEVER throws and
+ * always yields array-shaped queryConfigs / formulaConfigs, whatever garbage the
+ * database hands back.
+ */
+
+function queryConfig(metricVariable: string): MetricQueryConfigData {
+  return {
+    metricAliasData: {
+      metricVariable,
+      title: metricVariable,
+      description: metricVariable,
+      legend: metricVariable,
+      legendUnit: undefined,
+    },
+    metricQueryData: {
+      filterData: {},
+    },
+  } as unknown as MetricQueryConfigData;
+}
+
+function formulaConfig(metricVariable: string): MetricFormulaConfigData {
+  return {
+    metricAliasData: {
+      metricVariable,
+      title: metricVariable,
+      description: metricVariable,
+      legend: metricVariable,
+      legendUnit: undefined,
+    },
+    metricFormulaData: {
+      formula: "a + b",
+    },
+  } as unknown as MetricFormulaConfigData;
+}
+
+describe("MonitorStepMetricMonitorUtil.getMetricViewConfig", () => {
+  test("returns the config untouched when the step is well formed", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [queryConfig("a")];
+    const formulaConfigs: Array<MetricFormulaConfigData> = [formulaConfig("b")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: {
+          queryConfigs,
+          formulaConfigs,
+        },
+        rollingTime: RollingTime.Past1Hour,
+      });
+
+    expect(config.queryConfigs).toEqual(queryConfigs);
+    expect(config.formulaConfigs).toEqual(formulaConfigs);
+  });
+
+  test("returns empty arrays when the whole monitor is undefined", () => {
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(undefined);
+
+    expect(config).toEqual({ queryConfigs: [], formulaConfigs: [] });
+  });
+
+  test("returns empty arrays when the whole monitor is null", () => {
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(null);
+
+    expect(config).toEqual({ queryConfigs: [], formulaConfigs: [] });
+  });
+
+  test("THE CRASH: monitor present but metricViewConfig missing entirely", () => {
+    /*
+     * The exact shape from the bug report: a persisted metricMonitor that only
+     * carries rollingTime. Reading .metricViewConfig.queryConfigs off this is
+     * what threw and blanked the page.
+     */
+    const malformed: MonitorStepMetricMonitor = {
+      rollingTime: RollingTime.Past1Minute,
+    } as unknown as MonitorStepMetricMonitor;
+
+    expect(() => {
+      return MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed);
+    }).not.toThrow();
+
+    expect(MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed)).toEqual(
+      {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+    );
+  });
+
+  test("returns empty arrays when metricViewConfig is explicitly null", () => {
+    const malformed: MonitorStepMetricMonitor = {
+      metricViewConfig: null,
+      rollingTime: RollingTime.Past1Minute,
+    } as unknown as MonitorStepMetricMonitor;
+
+    expect(MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed)).toEqual(
+      { queryConfigs: [], formulaConfigs: [] },
+    );
+  });
+
+  test("fills in queryConfigs when only formulaConfigs was persisted", () => {
+    const formulaConfigs: Array<MetricFormulaConfigData> = [formulaConfig("b")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: { formulaConfigs },
+        rollingTime: RollingTime.Past1Minute,
+      } as unknown as MonitorStepMetricMonitor);
+
+    expect(config.queryConfigs).toEqual([]);
+    expect(config.formulaConfigs).toEqual(formulaConfigs);
+  });
+
+  test("fills in formulaConfigs when only queryConfigs was persisted", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [queryConfig("a")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: { queryConfigs },
+        rollingTime: RollingTime.Past1Minute,
+      } as unknown as MonitorStepMetricMonitor);
+
+    expect(config.queryConfigs).toEqual(queryConfigs);
+    expect(config.formulaConfigs).toEqual([]);
+  });
+
+  test.each([
+    ["null", null],
+    ["undefined", undefined],
+    ["a string", "not-an-array"],
+    ["a number", 42],
+    ["an object", { length: 2 }],
+    ["a boolean", true],
+  ])(
+    "coerces non-array queryConfigs (%s) to an empty array",
+    (_label: string, value: unknown) => {
+      const config: MetricsViewConfig =
+        MonitorStepMetricMonitorUtil.getMetricViewConfig({
+          metricViewConfig: {
+            queryConfigs: value,
+            formulaConfigs: value,
+          },
+          rollingTime: RollingTime.Past1Minute,
+        } as unknown as MonitorStepMetricMonitor);
+
+      expect(config.queryConfigs).toEqual([]);
+      expect(config.formulaConfigs).toEqual([]);
+      // Callers immediately call .length / .map / .some on these.
+      expect(Array.isArray(config.queryConfigs)).toBe(true);
+      expect(Array.isArray(config.formulaConfigs)).toBe(true);
+    },
+  );
+
+  test("the result is always safe for the array reads MetricView performs", () => {
+    const malformed: MonitorStepMetricMonitor =
+      {} as unknown as MonitorStepMetricMonitor;
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed);
+
+    // These are the exact operations MetricView runs on the data it is given.
+    expect(() => {
+      return [
+        config.queryConfigs.length,
+        config.queryConfigs.map((q: MetricQueryConfigData) => {
+          return q;
+        }),
+        config.queryConfigs.some(() => {
+          return true;
+        }),
+        config.formulaConfigs.length,
+        config.formulaConfigs.map((f: MetricFormulaConfigData) => {
+          return f;
+        }),
+      ];
+    }).not.toThrow();
+  });
+
+  test("does not mutate the monitor it was given", () => {
+    const malformed: MonitorStepMetricMonitor = {
+      rollingTime: RollingTime.Past1Minute,
+    } as unknown as MonitorStepMetricMonitor;
+
+    MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed);
+
+    expect(
+      (malformed as unknown as JSONObject)["metricViewConfig"],
+    ).toBeUndefined();
+  });
+
+  test("hands back the same array references when they are already valid", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [queryConfig("a")];
+    const formulaConfigs: Array<MetricFormulaConfigData> = [formulaConfig("b")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: { queryConfigs, formulaConfigs },
+        rollingTime: RollingTime.Past1Minute,
+      });
+
+    // No defensive copy: the preview passes these straight into MetricView.
+    expect(config.queryConfigs).toBe(queryConfigs);
+    expect(config.formulaConfigs).toBe(formulaConfigs);
+  });
+});
+
+describe("MonitorStepMetricMonitorUtil.getDefault", () => {
+  test("produces a config that resolves to itself", () => {
+    const defaultMonitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+
+    expect(
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(defaultMonitor),
+    ).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+    expect(defaultMonitor.rollingTime).toBe(RollingTime.Past1Minute);
+  });
+});
+
+describe("MonitorStepMetricMonitorUtil.fromJSON", () => {
+  test("normalizes JSON that is missing metricViewConfig", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({
+        rollingTime: RollingTime.Past1Hour,
+      });
+
+    expect(monitor.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+    expect(monitor.rollingTime).toBe(RollingTime.Past1Hour);
+  });
+
+  test("normalizes JSON that is missing everything", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({});
+
+    expect(monitor.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+    // rollingTime backs off to the same default a fresh step gets.
+    expect(monitor.rollingTime).toBe(RollingTime.Past1Minute);
+  });
+
+  test("preserves a well formed config", () => {
+    const json: JSONObject = {
+      metricViewConfig: {
+        queryConfigs: [queryConfig("a")],
+        formulaConfigs: [formulaConfig("b")],
+      },
+      rollingTime: RollingTime.Past7Days,
+    } as unknown as JSONObject;
+
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON(json);
+
+    expect(monitor.metricViewConfig.queryConfigs).toHaveLength(1);
+    expect(monitor.metricViewConfig.formulaConfigs).toHaveLength(1);
+    expect(monitor.rollingTime).toBe(RollingTime.Past7Days);
+  });
+
+  test("keeps unknown keys so forward-compatible fields are not dropped", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({
+        rollingTime: RollingTime.Past1Minute,
+        someFutureField: "keep-me",
+      } as unknown as JSONObject);
+
+    expect((monitor as unknown as JSONObject)["someFutureField"]).toBe(
+      "keep-me",
+    );
+  });
+
+  test("round trips through toJSON without losing the normalization", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({
+        rollingTime: RollingTime.Past1Minute,
+      });
+
+    const roundTripped: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON(
+        MonitorStepMetricMonitorUtil.toJSON(monitor),
+      );
+
+    expect(roundTripped.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+  });
+});
+
+describe("MonitorStep.fromJSON normalizes persisted metric monitors", () => {
+  function monitorStepJSON(metricMonitor: JSONObject | undefined): JSONObject {
+    return {
+      _type: "MonitorStep",
+      value: {
+        id: "step-1",
+        monitorCriteria: {
+          _type: "MonitorCriteria",
+          value: {
+            monitorCriteriaInstanceArray: [],
+          },
+        },
+        metricMonitor: metricMonitor,
+      },
+    } as unknown as JSONObject;
+  }
+
+  test("a step whose metricMonitor has no metricViewConfig loads with one", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(
+      monitorStepJSON({
+        rollingTime: RollingTime.Past1Minute,
+      } as unknown as JSONObject),
+    );
+
+    expect(step.data?.metricMonitor?.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+  });
+
+  test("the loaded step is safe to hand to the metric preview", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(
+      monitorStepJSON({} as unknown as JSONObject),
+    );
+
+    expect(() => {
+      const config: MetricsViewConfig =
+        MonitorStepMetricMonitorUtil.getMetricViewConfig(
+          step.data?.metricMonitor,
+        );
+
+      return [config.queryConfigs.length, config.formulaConfigs.length];
+    }).not.toThrow();
+  });
+
+  test("a step with no metricMonitor at all stays undefined", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(monitorStepJSON(undefined));
+
+    expect(step.data?.metricMonitor).toBeUndefined();
+  });
+
+  test("a well formed metricMonitor survives the load unchanged", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(
+      monitorStepJSON({
+        metricViewConfig: {
+          queryConfigs: [queryConfig("a")],
+          formulaConfigs: [],
+        },
+        rollingTime: RollingTime.Past1Hour,
+      } as unknown as JSONObject),
+    );
+
+    expect(
+      step.data?.metricMonitor?.metricViewConfig.queryConfigs,
+    ).toHaveLength(1);
+    expect(step.data?.metricMonitor?.rollingTime).toBe(RollingTime.Past1Hour);
+  });
+});

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

@@ -0,0 +1,185 @@
+import Profile from "../../../Models/AnalyticsModels/Profile";
+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 MonitorStepProfileMonitor, {
+  MonitorStepProfileMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepProfileMonitor";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("MonitorStepProfileMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an empty monitor scoped to the last 60 seconds", () => {
+      const def: MonitorStepProfileMonitor =
+        MonitorStepProfileMonitorUtil.getDefault();
+
+      expect(def.attributes).toEqual({});
+      expect(def.profileType).toBe("");
+      expect(def.profileTypes).toEqual([]);
+      expect(def.telemetryServiceIds).toEqual([]);
+      expect(def.entityKeys).toEqual([]);
+      expect(def.lastXSecondsOfProfiles).toBe(60);
+    });
+  });
+
+  describe("toQuery", () => {
+    test("builds only the time window for the empty default", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(
+        MonitorStepProfileMonitorUtil.getDefault(),
+      );
+
+      // Only the rolling time window is present.
+      expect(query.startTime).toBeInstanceOf(InBetween);
+      expect(query.primaryEntityId).toBeUndefined();
+      expect(query.entityKeys).toBeUndefined();
+      expect(query.attributes).toBeUndefined();
+      expect(query.profileType).toBeUndefined();
+    });
+
+    test("builds no filters at all when the time window is disabled", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query).toEqual({});
+    });
+
+    test("scopes to telemetry services when provided", () => {
+      const serviceId: ObjectID = ObjectID.generate();
+
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        telemetryServiceIds: [serviceId],
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.primaryEntityId).toBeInstanceOf(Includes);
+      expect((query.primaryEntityId as Includes).values).toEqual([serviceId]);
+    });
+
+    test("scopes to entity keys when provided", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        entityKeys: ["host-1", "pod-2"],
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.entityKeys).toBeInstanceOf(Includes);
+      expect((query.entityKeys as Includes).values).toEqual([
+        "host-1",
+        "pod-2",
+      ]);
+    });
+
+    test("passes attributes through only when non-empty", () => {
+      const withAttrs: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        attributes: { "service.name": "checkout" },
+        lastXSecondsOfProfiles: 0,
+      });
+      expect(withAttrs.attributes).toEqual({ "service.name": "checkout" });
+
+      const withoutAttrs: Query<Profile> =
+        MonitorStepProfileMonitorUtil.toQuery({
+          ...MonitorStepProfileMonitorUtil.getDefault(),
+          attributes: {},
+          lastXSecondsOfProfiles: 0,
+        });
+      expect(withoutAttrs.attributes).toBeUndefined();
+    });
+
+    test("uses Includes for profileTypes", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        profileTypes: ["cpu", "heap"],
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.profileType).toBeInstanceOf(Includes);
+      expect((query.profileType as unknown as Includes).values).toEqual([
+        "cpu",
+        "heap",
+      ]);
+    });
+
+    test("a single profileType wins over profileTypes as a Search", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        profileTypes: ["cpu", "heap"],
+        profileType: "cpu",
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.profileType).toBeInstanceOf(Search);
+      expect((query.profileType as unknown as Search<string>).value).toBe(
+        "cpu",
+      );
+    });
+
+    test("builds a bounded time window from lastXSecondsOfProfiles", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        lastXSecondsOfProfiles: 120,
+      });
+
+      const window: InBetween<Date> = query.startTime as InBetween<Date>;
+      expect(window).toBeInstanceOf(InBetween);
+
+      const spanMs: number =
+        window.endValue.getTime() - window.startValue.getTime();
+      // 120 seconds, allowing a small margin for clock advance during the call.
+      expect(spanMs).toBeGreaterThanOrEqual(119 * 1000);
+      expect(spanMs).toBeLessThanOrEqual(121 * 1000);
+    });
+  });
+
+  describe("round-trip", () => {
+    test("fromJSON(toJSON(x)) preserves a populated monitor", () => {
+      const monitor: MonitorStepProfileMonitor = {
+        attributes: { env: "prod", replicas: 3, canary: true },
+        profileType: "cpu",
+        profileTypes: ["cpu", "heap"],
+        telemetryServiceIds: [ObjectID.generate(), ObjectID.generate()],
+        entityKeys: ["host-1"],
+        lastXSecondsOfProfiles: 300,
+      };
+
+      const json: JSONObject = MonitorStepProfileMonitorUtil.toJSON(monitor);
+      const roundTripped: MonitorStepProfileMonitor =
+        MonitorStepProfileMonitorUtil.fromJSON(json);
+
+      expect(roundTripped.attributes).toEqual(monitor.attributes);
+      expect(roundTripped.profileType).toBe(monitor.profileType);
+      expect(roundTripped.profileTypes).toEqual(monitor.profileTypes);
+      expect(roundTripped.entityKeys).toEqual(monitor.entityKeys);
+      expect(roundTripped.lastXSecondsOfProfiles).toBe(
+        monitor.lastXSecondsOfProfiles,
+      );
+      expect(
+        roundTripped.telemetryServiceIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ).toEqual(
+        monitor.telemetryServiceIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      );
+    });
+
+    test("fromJSON defaults entityKeys to an empty array when absent", () => {
+      const parsed: MonitorStepProfileMonitor =
+        MonitorStepProfileMonitorUtil.fromJSON({
+          attributes: {},
+          profileType: "",
+          profileTypes: [],
+          telemetryServiceIds: [],
+          lastXSecondsOfProfiles: 60,
+        });
+
+      expect(parsed.entityKeys).toEqual([]);
+    });
+  });
+});