@oneuptime/common 11.7.4 → 12.0.1

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

@@ -0,0 +1,285 @@
+import {
+  RumAlertTemplate,
+  RumAlertTemplateArgs,
+  getAllRumAlertTemplates,
+  getRumAlertTemplateById,
+} from "../../../Types/Monitor/RumAlertTemplates";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import RollingTime from "../../../Types/RollingTime/RollingTime";
+import ObjectID from "../../../Types/ObjectID";
+import { SpanStatus } from "../../../Models/AnalyticsModels/Span";
+import MonitorStepMetricMonitor from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MonitorStepTraceMonitor from "../../../Types/Monitor/MonitorStepTraceMonitor";
+import MonitorStepExceptionMonitor from "../../../Types/Monitor/MonitorStepExceptionMonitor";
+
+const RUM_APPLICATION_ID: ObjectID = ObjectID.generate();
+
+function buildArgs(): RumAlertTemplateArgs {
+  return {
+    rumApplicationId: RUM_APPLICATION_ID.toString(),
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Storefront",
+  };
+}
+
+function getTemplate(id: string): RumAlertTemplate {
+  const template: RumAlertTemplate | undefined = getRumAlertTemplateById(id);
+
+  if (!template) {
+    throw new Error(`Missing RUM template ${id}`);
+  }
+
+  return template;
+}
+
+function getCriteria(step: MonitorStep): Array<MonitorCriteriaInstance> {
+  return step.data?.monitorCriteria?.data?.monitorCriteriaInstanceArray || [];
+}
+
+interface WebVitalCase {
+  id: string;
+  metricName: string;
+  metricAlias: string;
+  threshold: number;
+  unit: string;
+  severity: string;
+}
+
+const WEB_VITAL_CASES: Array<WebVitalCase> = [
+  {
+    id: "rum-poor-lcp",
+    metricName: "web_vital.lcp",
+    metricAlias: "rum_lcp",
+    threshold: 4000,
+    unit: "ms",
+    severity: "Critical",
+  },
+  {
+    id: "rum-poor-inp",
+    metricName: "web_vital.inp",
+    metricAlias: "rum_inp",
+    threshold: 500,
+    unit: "ms",
+    severity: "Critical",
+  },
+  {
+    id: "rum-poor-cls",
+    metricName: "web_vital.cls",
+    metricAlias: "rum_cls",
+    threshold: 0.25,
+    unit: "1",
+    severity: "Critical",
+  },
+  {
+    id: "rum-slow-fcp",
+    metricName: "web_vital.fcp",
+    metricAlias: "rum_fcp",
+    threshold: 3000,
+    unit: "ms",
+    severity: "Warning",
+  },
+  {
+    id: "rum-slow-ttfb",
+    metricName: "web_vital.ttfb",
+    metricAlias: "rum_ttfb",
+    threshold: 1800,
+    unit: "ms",
+    severity: "Warning",
+  },
+];
+
+describe("RumAlertTemplates", () => {
+  test("registers every template exactly once", () => {
+    const templates: Array<RumAlertTemplate> = getAllRumAlertTemplates();
+    const ids: Array<string> = templates.map((template: RumAlertTemplate) => {
+      return template.id;
+    });
+
+    expect(templates).toHaveLength(7);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ids).toEqual([
+      ...WEB_VITAL_CASES.map((item: WebVitalCase) => {
+        return item.id;
+      }),
+      "rum-failed-user-operations",
+      "rum-unhandled-exceptions",
+    ]);
+  });
+
+  test("does not expose its internal template array", () => {
+    const first: Array<RumAlertTemplate> = getAllRumAlertTemplates();
+    first.pop();
+
+    expect(getAllRumAlertTemplates()).toHaveLength(7);
+  });
+
+  test("returns undefined for an unknown template id", () => {
+    expect(getRumAlertTemplateById("rum-does-not-exist")).toBeUndefined();
+  });
+
+  test.each(WEB_VITAL_CASES)(
+    "$id scopes $metricName to the RUM application and evaluates its poor boundary",
+    (item: WebVitalCase) => {
+      const template: RumAlertTemplate = getTemplate(item.id);
+      const step: MonitorStep = template.getMonitorStep(buildArgs());
+      const metricMonitor: MonitorStepMetricMonitor | undefined =
+        step.data?.metricMonitor;
+
+      expect(template.monitorType).toBe(MonitorType.Metrics);
+      expect(template.category).toBe("Core Web Vitals");
+      expect(template.severity).toBe(item.severity);
+      expect(metricMonitor).toBeDefined();
+      expect(metricMonitor?.rollingTime).toBe(RollingTime.Past5Minutes);
+      expect(
+        metricMonitor?.telemetryServiceIds?.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ).toEqual([RUM_APPLICATION_ID.toString()]);
+
+      const query: MetricQueryConfigData | undefined =
+        metricMonitor?.metricViewConfig.queryConfigs[0];
+
+      expect(metricMonitor?.metricViewConfig.queryConfigs).toHaveLength(1);
+      expect(metricMonitor?.metricViewConfig.formulaConfigs).toEqual([]);
+      expect(query?.metricQueryData.filterData.metricName).toBe(
+        item.metricName,
+      );
+      expect(query?.metricQueryData.filterData.aggegationType).toBe(
+        MetricsAggregationType.Avg,
+      );
+      expect(query?.metricAliasData?.metricVariable).toBe(item.metricAlias);
+      expect(query?.metricAliasData?.legendUnit).toBe(item.unit);
+
+      const [unhealthy, healthy]: Array<MonitorCriteriaInstance> =
+        getCriteria(step);
+      const unhealthyFilter: CriteriaFilter | undefined =
+        unhealthy?.data?.filters[0];
+      const healthyFilter: CriteriaFilter | undefined =
+        healthy?.data?.filters[0];
+
+      expect(getCriteria(step)).toHaveLength(2);
+      expect(unhealthyFilter?.checkOn).toBe(CheckOn.MetricValue);
+      expect(unhealthyFilter?.filterType).toBe(FilterType.GreaterThanOrEqualTo);
+      expect(unhealthyFilter?.value).toBe(item.threshold);
+      expect(unhealthyFilter?.metricMonitorOptions?.metricAlias).toBe(
+        item.metricAlias,
+      );
+      expect(unhealthyFilter?.metricMonitorOptions?.metricAggregationType).toBe(
+        EvaluateOverTimeType.Average,
+      );
+      expect(unhealthyFilter?.metricMonitorOptions?.thresholdUnit).toBe(
+        item.unit,
+      );
+      expect(healthyFilter?.filterType).toBe(FilterType.LessThan);
+      expect(healthyFilter?.value).toBe(item.threshold);
+    },
+  );
+
+  test("failed user operations watch only error spans for this application over five minutes", () => {
+    const template: RumAlertTemplate = getTemplate(
+      "rum-failed-user-operations",
+    );
+    const step: MonitorStep = template.getMonitorStep(buildArgs());
+    const traceMonitor: MonitorStepTraceMonitor | undefined =
+      step.data?.traceMonitor;
+
+    expect(template.monitorType).toBe(MonitorType.Traces);
+    expect(template.category).toBe("Errors");
+    expect(traceMonitor?.spanStatuses).toEqual([SpanStatus.Error]);
+    expect(traceMonitor?.lastXSecondsOfSpans).toBe(300);
+    expect(traceMonitor?.attributes).toEqual({});
+    expect(traceMonitor?.spanName).toBe("");
+    expect(
+      traceMonitor?.telemetryServiceIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([RUM_APPLICATION_ID.toString()]);
+
+    const [unhealthy, healthy]: Array<MonitorCriteriaInstance> =
+      getCriteria(step);
+
+    expect(unhealthy?.data?.filters[0]?.checkOn).toBe(CheckOn.SpanCount);
+    expect(unhealthy?.data?.filters[0]?.filterType).toBe(
+      FilterType.GreaterThan,
+    );
+    expect(unhealthy?.data?.filters[0]?.value).toBe(0);
+    expect(healthy?.data?.filters[0]?.filterType).toBe(
+      FilterType.LessThanOrEqualTo,
+    );
+  });
+
+  test("unhandled exceptions exclude resolved and archived groups and stay application-scoped", () => {
+    const template: RumAlertTemplate = getTemplate("rum-unhandled-exceptions");
+    const step: MonitorStep = template.getMonitorStep(buildArgs());
+    const exceptionMonitor: MonitorStepExceptionMonitor | undefined =
+      step.data?.exceptionMonitor;
+
+    expect(template.monitorType).toBe(MonitorType.Exceptions);
+    expect(template.category).toBe("Errors");
+    expect(exceptionMonitor?.lastXSecondsOfExceptions).toBe(300);
+    expect(exceptionMonitor?.includeResolved).toBe(false);
+    expect(exceptionMonitor?.includeArchived).toBe(false);
+    expect(exceptionMonitor?.exceptionTypes).toEqual([]);
+    expect(exceptionMonitor?.message).toBe("");
+    expect(
+      exceptionMonitor?.telemetryServiceIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([RUM_APPLICATION_ID.toString()]);
+
+    const [unhealthy, healthy]: Array<MonitorCriteriaInstance> =
+      getCriteria(step);
+
+    expect(unhealthy?.data?.filters[0]?.checkOn).toBe(CheckOn.ExceptionCount);
+    expect(unhealthy?.data?.filters[0]?.filterType).toBe(
+      FilterType.GreaterThan,
+    );
+    expect(healthy?.data?.filters[0]?.filterType).toBe(
+      FilterType.LessThanOrEqualTo,
+    );
+  });
+
+  test("every template has one breach criteria and one inert recovery criteria", () => {
+    for (const template of getAllRumAlertTemplates()) {
+      const [breach, recovery]: Array<MonitorCriteriaInstance> = getCriteria(
+        template.getMonitorStep(buildArgs()),
+      );
+
+      expect(breach?.data?.createIncidents).toBe(true);
+      expect(breach?.data?.createAlerts).toBe(true);
+      expect(breach?.data?.incidents).toHaveLength(1);
+      expect(breach?.data?.alerts).toHaveLength(1);
+      expect(breach?.data?.incidents[0]?.title).toContain("[RUM]");
+      expect(breach?.data?.alerts[0]?.title).toContain("[RUM]");
+
+      expect(recovery?.data?.createIncidents).toBe(false);
+      expect(recovery?.data?.createAlerts).toBe(false);
+      expect(recovery?.data?.incidents).toEqual([]);
+      expect(recovery?.data?.alerts).toEqual([]);
+    }
+  });
+
+  test("metric monitor serialization preserves the RUM application scope", () => {
+    const original: MonitorStep =
+      getTemplate("rum-poor-lcp").getMonitorStep(buildArgs());
+    const restored: MonitorStep = MonitorStep.fromJSON(original.toJSON());
+
+    expect(restored.data?.metricMonitor?.telemetryServiceIds).toHaveLength(1);
+    expect(
+      restored.data?.metricMonitor?.telemetryServiceIds?.[0]?.toString(),
+    ).toBe(RUM_APPLICATION_ID.toString());
+  });
+});

package/Tests/Types/Podman/PodmanInventoryExtractor.test.ts

@@ -0,0 +1,159 @@
+import { ParsedPodmanResource } from "../../../Server/Services/PodmanResourceService";
+import {
+  INVENTORIED_PODMAN_KINDS,
+  INVENTORY_KIND_ATTRIBUTE,
+  canonicalPodmanKind,
+  extractPodmanInventoryResource,
+  isInventoriedPodmanKind,
+} from "../../../Types/Podman/PodmanInventoryExtractor";
+import { describe, expect, it } from "@jest/globals";
+
+const lastSeenAt: Date = new Date("2026-07-31T12:00:00.000Z");
+
+type ExtractFunction = (
+  kind: string,
+  body: unknown,
+) => ParsedPodmanResource | null;
+
+const extract: ExtractFunction = (
+  kind: string,
+  body: unknown,
+): ParsedPodmanResource | null => {
+  const result: { resource: ParsedPodmanResource } | null =
+    extractPodmanInventoryResource({
+      kind,
+      logBody: typeof body === "string" ? body : JSON.stringify(body),
+      lastSeenAt,
+    });
+  return result ? result.resource : null;
+};
+
+describe("PodmanInventoryExtractor constants", () => {
+  it("exposes the podman kind attribute key", () => {
+    expect(INVENTORY_KIND_ATTRIBUTE).toBe("oneuptime.podman.kind");
+  });
+
+  it("models exactly the four podman resource kinds", () => {
+    expect([...INVENTORIED_PODMAN_KINDS]).toEqual([
+      "Container",
+      "Image",
+      "Network",
+      "Volume",
+    ]);
+  });
+});
+
+describe("isInventoriedPodmanKind", () => {
+  it("accepts canonical kinds case-insensitively", () => {
+    expect(isInventoriedPodmanKind("Image")).toBe(true);
+    expect(isInventoriedPodmanKind("network")).toBe(true);
+    expect(isInventoriedPodmanKind("CONTAINER")).toBe(true);
+  });
+
+  it("rejects unmodeled kinds", () => {
+    expect(isInventoriedPodmanKind("Pod")).toBe(false);
+    expect(isInventoriedPodmanKind("")).toBe(false);
+  });
+});
+
+describe("canonicalPodmanKind", () => {
+  it("normalizes singular, plural and mixed case", () => {
+    expect(canonicalPodmanKind("volumes")).toBe("Volume");
+    expect(canonicalPodmanKind("  Container ")).toBe("Container");
+    expect(canonicalPodmanKind("IMAGE")).toBe("Image");
+  });
+
+  it("returns null for empty and unknown kinds", () => {
+    expect(canonicalPodmanKind("")).toBeNull();
+    expect(canonicalPodmanKind("pod")).toBeNull();
+  });
+});
+
+describe("extractPodmanInventoryResource - guard cases", () => {
+  it("returns null for an unmodeled kind", () => {
+    expect(extract("Pod", { Name: "x" })).toBeNull();
+  });
+
+  it("returns null for malformed JSON", () => {
+    expect(extract("Container", "{bad")).toBeNull();
+  });
+
+  it("returns null for a JSON array body", () => {
+    expect(extract("Volume", [1, 2])).toBeNull();
+  });
+});
+
+describe("extractPodmanInventoryResource - resources", () => {
+  it("parses a container envelope, stripping slash and lowercasing state", () => {
+    const resource: ParsedPodmanResource | null = extract("Container", {
+      kind: "Container",
+      data: {
+        Id: "aabbccddeeff00112233",
+        Names: "/db,/db-1",
+        Image: "postgres:16",
+        State: "RUNNING",
+        CreatedAt: "2026-07-30T09:00:00.000Z",
+        Labels: { tier: "data" },
+      },
+    });
+
+    expect(resource).not.toBeNull();
+    expect(resource!.kind).toBe("Container");
+    expect(resource!.name).toBe("db");
+    expect(resource!.containerId).toBe("aabbccddeeff");
+    expect(resource!.imageName).toBe("postgres:16");
+    expect(resource!.state).toBe("running");
+    expect(resource!.labels).toEqual({ tier: "data" });
+    expect(resource!.lastSeenAt).toBe(lastSeenAt);
+    expect(resource!.resourceCreationTimestamp!.getTime()).toBe(
+      new Date("2026-07-30T09:00:00.000Z").getTime(),
+    );
+  });
+
+  it("returns null for a container with no usable name", () => {
+    expect(extract("Container", { Id: "x", Names: "  , " })).toBeNull();
+  });
+
+  it("builds an image name from repository and tag and strips sha256", () => {
+    const resource: ParsedPodmanResource | null = extract("Image", {
+      ID: "sha256:0011223344556677",
+      Repository: "redis",
+      Tag: "7",
+    });
+    expect(resource!.name).toBe("redis:7");
+    expect(resource!.containerId).toBe("001122334455");
+    expect(resource!.imageName).toBeNull();
+  });
+
+  it("skips a dangling image", () => {
+    expect(
+      extract("Image", { Repository: "<none>", Tag: "<none>" }),
+    ).toBeNull();
+  });
+
+  it("encodes driver/scope for a network and truncates id", () => {
+    const resource: ParsedPodmanResource | null = extract("Network", {
+      Id: "netaaaabbbbcccc",
+      Name: "podman",
+      Driver: "bridge",
+      Scope: "local",
+    });
+    expect(resource!.state).toBe("bridge/local");
+    expect(resource!.containerId).toBe("netaaaabbbbc");
+  });
+
+  it("parses a volume with a null containerId", () => {
+    const resource: ParsedPodmanResource | null = extract("Volume", {
+      Name: "cache",
+      Driver: "local",
+    });
+    expect(resource!.kind).toBe("Volume");
+    expect(resource!.name).toBe("cache");
+    expect(resource!.state).toBe("local");
+    expect(resource!.containerId).toBeNull();
+  });
+
+  it("returns null for a volume without a name", () => {
+    expect(extract("Volume", { Driver: "local" })).toBeNull();
+  });
+});