@oneuptime/common 11.6.1 → 11.7.0

package/Tests/Server/Utils/Memory.test.ts

@@ -0,0 +1,213 @@
+import MemoryUtil from "../../../Server/Utils/Memory";
+import fs from "fs";
+import os from "os";
+
+/*
+ * MemoryUtil decides how much memory a process may assume it has. On a host
+ * it is os.freemem(); inside a container it must be the cgroup headroom,
+ * because os.freemem() reports the whole node and would happily let a
+ * container allocate its way to an OOM kill.
+ *
+ * The cgroup files do not exist on the dev machines these tests run on, so
+ * fs.readFileSync is stubbed per-path. That is the only way to exercise the
+ * v2 -> v1 -> null fallback chain and the "max"/unlimited handling at all.
+ */
+
+const CGROUP_V2_LIMIT: string = "/sys/fs/cgroup/memory.max";
+const CGROUP_V2_USAGE: string = "/sys/fs/cgroup/memory.current";
+const CGROUP_V1_LIMIT: string = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
+const CGROUP_V1_USAGE: string = "/sys/fs/cgroup/memory/memory.usage_in_bytes";
+
+type StubCgroupFilesFunction = (files: Record<string, string>) => void;
+
+/*
+ * Makes readFileSync answer only for the given paths and throw ENOENT for
+ * everything else, which is what the real filesystem does when a cgroup
+ * version is not in use.
+ */
+const stubCgroupFiles: StubCgroupFilesFunction = (
+  files: Record<string, string>,
+): void => {
+  jest
+    .spyOn(fs, "readFileSync")
+    .mockImplementation((path: fs.PathOrFileDescriptor): string => {
+      const value: string | undefined = files[String(path)];
+
+      if (value === undefined) {
+        throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+      }
+
+      return value;
+    });
+};
+
+describe("MemoryUtil", () => {
+  const hostFreeMemory: number = 8 * 1024 * 1024 * 1024;
+
+  beforeEach(() => {
+    jest.spyOn(os, "freemem").mockReturnValue(hostFreeMemory);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("getHostFreeMemoryInBytes", () => {
+    test("should report what the os reports", () => {
+      expect(MemoryUtil.getHostFreeMemoryInBytes()).toEqual(hostFreeMemory);
+    });
+  });
+
+  describe("getCgroupAvailableMemoryInBytes", () => {
+    test("should return null when no cgroup files exist", () => {
+      stubCgroupFiles({});
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toBeNull();
+    });
+
+    test("should return limit minus usage for cgroup v2", () => {
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "1000",
+        [CGROUP_V2_USAGE]: "400",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toEqual(600);
+    });
+
+    test("should tolerate trailing whitespace in the cgroup files", () => {
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "1000\n",
+        [CGROUP_V2_USAGE]: " 400 \n",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toEqual(600);
+    });
+
+    test("should never report negative headroom", () => {
+      // Usage above the limit happens transiently; clamp at zero.
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "1000",
+        [CGROUP_V2_USAGE]: "1500",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toEqual(0);
+    });
+
+    test("should fall back to cgroup v1 when v2 says 'max'", () => {
+      /*
+       * "max" is how cgroup v2 spells "no limit", so it must not be read as a
+       * number and must not stop the v1 lookup.
+       */
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "max",
+        [CGROUP_V2_USAGE]: "400",
+        [CGROUP_V1_LIMIT]: "2000",
+        [CGROUP_V1_USAGE]: "500",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toEqual(1500);
+    });
+
+    test("should fall back to cgroup v1 when v2 files are absent", () => {
+      stubCgroupFiles({
+        [CGROUP_V1_LIMIT]: "2000",
+        [CGROUP_V1_USAGE]: "500",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toEqual(1500);
+    });
+
+    test("should ignore an absurdly large limit as 'unlimited'", () => {
+      /*
+       * This is the literal sentinel an unconstrained cgroup v1 reports
+       * (PAGE_COUNTER_MAX, just under 2^63). It means "no limit", not "you
+       * have exabytes free".
+       */
+      const unlimited: string = "9223372036854771712";
+
+      stubCgroupFiles({
+        [CGROUP_V1_LIMIT]: unlimited,
+        [CGROUP_V1_USAGE]: "500",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toBeNull();
+    });
+
+    test("should honour a realistic multi-gigabyte container limit", () => {
+      /*
+       * Regression guard for the unlimited threshold. It must be large enough
+       * that ordinary container limits fall below it — a 2 GiB limit is a
+       * real limit, not the "no limit" sentinel, and treating it as unlimited
+       * silently disables container awareness for essentially every
+       * deployment.
+       */
+      const twoGiB: number = 2 * 1024 * 1024 * 1024;
+      const oneGiB: number = 1 * 1024 * 1024 * 1024;
+
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: String(twoGiB),
+        [CGROUP_V2_USAGE]: String(oneGiB),
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toEqual(oneGiB);
+    });
+
+    test("should return null when the limit is present but usage is not", () => {
+      stubCgroupFiles({ [CGROUP_V2_LIMIT]: "1000" });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toBeNull();
+    });
+
+    test("should return null for a non-numeric limit", () => {
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "not-a-number",
+        [CGROUP_V2_USAGE]: "400",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toBeNull();
+    });
+
+    test("should return null for a zero or negative limit", () => {
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "0",
+        [CGROUP_V2_USAGE]: "0",
+      });
+
+      expect(MemoryUtil.getCgroupAvailableMemoryInBytes()).toBeNull();
+    });
+  });
+
+  describe("getContainerAwareAvailableMemoryInBytes", () => {
+    test("should use host free memory when there is no cgroup limit", () => {
+      stubCgroupFiles({});
+
+      expect(MemoryUtil.getContainerAwareAvailableMemoryInBytes()).toEqual(
+        hostFreeMemory,
+      );
+    });
+
+    test("should never exceed the container's headroom", () => {
+      /*
+       * This is the whole point of the helper: the host has 8GB free but the
+       * container may only use 600 bytes more.
+       */
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "1000",
+        [CGROUP_V2_USAGE]: "400",
+      });
+
+      expect(MemoryUtil.getContainerAwareAvailableMemoryInBytes()).toEqual(600);
+    });
+
+    test("should use host free memory when it is the smaller of the two", () => {
+      jest.spyOn(os, "freemem").mockReturnValue(100);
+
+      stubCgroupFiles({
+        [CGROUP_V2_LIMIT]: "1000",
+        [CGROUP_V2_USAGE]: "0",
+      });
+
+      expect(MemoryUtil.getContainerAwareAvailableMemoryInBytes()).toEqual(100);
+    });
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/LogMonitorCriteria.test.ts

@@ -130,6 +130,36 @@ describe("LogMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
     });
   });
 
+  /*
+   * The exact production shape of a "log presence" alert: criteria
+   * "Log Count >= 1" flips the monitor Offline the moment a matching log
+   * line is ingested. Documents the comparator behavior downstream of
+   * countBy — the countBy parsing regression itself (ClickHouse >= 25.x
+   * returning count() as a JSON number) is pinned in
+   * AnalyticsDatabaseService.test.ts.
+   */
+  describe("log-presence offline criteria (Log Count >= 1)", () => {
+    const offlineCriteria: CriteriaFilter = {
+      checkOn: CheckOn.LogCount,
+      filterType: FilterType.GreaterThanOrEqualTo,
+      value: 1,
+    };
+
+    test("one matching log → met (monitor goes offline)", async () => {
+      const result: string | null = await evaluate(1, offlineCriteria);
+      expect(result).toBeTruthy();
+      expect(result).toContain("Log Count");
+    });
+
+    test("many matching logs → met", async () => {
+      expect(await evaluate(6718284, offlineCriteria)).toBeTruthy();
+    });
+
+    test("zero matching logs → not met (monitor stays operational)", async () => {
+      expect(await evaluate(0, offlineCriteria)).toBeNull();
+    });
+  });
+
   describe("edge cases", () => {
     test("a missing logCount is treated as 0", async () => {
       // undefined logCount → 0; "equal to 0" is therefore met.

package/Tests/Server/Utils/Monitor/Criteria/SnmpMonitorCriteria.test.ts

@@ -1,10 +1,16 @@
 import SnmpMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/SnmpMonitorCriteria";
+import MetricBaselineService, {
+  BaselineSummary,
+} from "../../../../../Server/Services/MetricBaselineService";
 import {
+  AnomalyDetectionSensitivity,
   CheckOn,
   CriteriaFilter,
   FilterType,
 } from "../../../../../Types/Monitor/CriteriaFilter";
+import MonitorMetricType from "../../../../../Types/Monitor/MonitorMetricType";
 import SnmpDataType from "../../../../../Types/Monitor/SnmpMonitor/SnmpDataType";
+import SnmpInterface from "../../../../../Types/Monitor/SnmpMonitor/SnmpInterface";
 import SnmpMonitorResponse, {
   SnmpOidResponse,
 } from "../../../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
@@ -15,6 +21,7 @@ const PSU_OID: string = "1.3.6.1.4.1.674.10892.5.4.600.12.1.5.1.2";
 
 function buildDataToProcess(input: {
   oidResponses: Array<SnmpOidResponse>;
+  interfaces?: Array<SnmpInterface>;
   isOnline?: boolean;
   responseTimeInMs?: number;
 }): ProbeMonitorResponse {
@@ -23,6 +30,7 @@ function buildDataToProcess(input: {
     responseTimeInMs: input.responseTimeInMs ?? 42,
     failureCause: "",
     oidResponses: input.oidResponses,
+    ...(input.interfaces ? { interfaces: input.interfaces } : {}),
   };
 
   return {
@@ -36,6 +44,41 @@ function buildDataToProcess(input: {
   };
 }
 
+function buildInterface(input: {
+  name: string;
+  utilizationPercent?: number | undefined;
+  alias?: string | undefined;
+}): SnmpInterface {
+  return {
+    interfaceIndex: 1,
+    name: input.name,
+    alias: input.alias,
+    isOperationallyUp: true,
+    isAdministrativelyUp: true,
+    utilizationPercent: input.utilizationPercent,
+  };
+}
+
+function buildBaseline(input: {
+  mean: number;
+  stddev: number;
+  sampleCount?: number;
+  isReliable?: boolean;
+}): BaselineSummary {
+  return {
+    sampleCount: input.sampleCount ?? 100,
+    mean: input.mean,
+    stddev: input.stddev,
+    median: input.mean,
+    p95: input.mean + 2 * input.stddev,
+    minObserved: input.mean - 2 * input.stddev,
+    maxObserved: input.mean + 2 * input.stddev,
+    isReliable: input.isReliable ?? true,
+    windowDays: 14,
+    hourOfWeek: 10,
+  };
+}
+
 describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
   describe("SnmpOidValue with Integer values (regression for issue #2439)", () => {
     test("Integer 3 equals 3 → criteria is met", async () => {
@@ -374,4 +417,346 @@ describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       expect(result).toContain("does not exist");
     });
   });
+
+  describe("SnmpInterfaceUtilizationPercent anomaly filters", () => {
+    let getBaselineSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      getBaselineSpy = jest.spyOn(MetricBaselineService, "getBaseline");
+    });
+
+    afterEach(() => {
+      getBaselineSpy.mockRestore();
+    });
+
+    test("AnomalouslyHigh fires when utilization exceeds mean + 3σ (Medium default)", async () => {
+      // mean 20, σ 5 → 3σ band is [5, 35]; observed 90 breaches high.
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 90 })],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeTruthy();
+      expect(result).toContain("above the same-hour baseline");
+      expect(result).toContain("90.00%");
+    });
+
+    test("baseline lookup is keyed by monitorId and the utilization metric name", async () => {
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 90 })],
+      });
+
+      await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess,
+        criteriaFilter,
+      });
+
+      expect(getBaselineSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectId: dataToProcess.projectId.toString(),
+          primaryEntityId: dataToProcess.monitorId.toString(),
+          metricName: MonitorMetricType.SnmpInterfaceUtilizationPercent,
+        }),
+      );
+    });
+
+    test("no fire when utilization is inside the expected band", async () => {
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 25 })],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("AnomalouslyLow fires when utilization drops below mean - 3σ", async () => {
+      // mean 50, σ 10 → 3σ band is [20, 80]; observed 2 breaches low.
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 50, stddev: 10 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyLow,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 2 })],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeTruthy();
+      expect(result).toContain("below the same-hour baseline");
+    });
+
+    test("Anomalous (either direction) fires on a high breach", async () => {
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.Anomalous,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 99 })],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeTruthy();
+    });
+
+    test("High sensitivity (2σ) fires where Medium (3σ) would not", async () => {
+      // mean 20, σ 5 → 2σ band tops out at 30; observed 32 breaches at 2σ only.
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+        metricMonitorOptions: {
+          anomalyDetection: {
+            sensitivity: AnomalyDetectionSensitivity.High,
+          },
+        },
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 32 })],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeTruthy();
+      expect(result).toContain("sensitivity High");
+    });
+
+    test("no baseline yet (learning) → never fires", async () => {
+      getBaselineSpy.mockResolvedValue(null);
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [
+          buildInterface({ name: "Gi0/1", utilizationPercent: 100 }),
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("unreliable (thin) baseline → never fires", async () => {
+      getBaselineSpy.mockResolvedValue(
+        buildBaseline({ mean: 20, stddev: 5, isReliable: false }),
+      );
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [
+          buildInterface({ name: "Gi0/1", utilizationPercent: 100 }),
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("zero-variance baseline → never fires", async () => {
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 0 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [
+          buildInterface({ name: "Gi0/1", utilizationPercent: 100 }),
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("interface scope applies: only the scoped interface's utilization is observed", async () => {
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+        snmpMonitorOptions: { interfaceName: "Gi0/2" },
+      };
+
+      // Out-of-scope Gi0/1 is anomalous; in-scope Gi0/2 is normal.
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [
+          buildInterface({ name: "Gi0/1", utilizationPercent: 99 }),
+          buildInterface({ name: "Gi0/2", utilizationPercent: 22 }),
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("no interfaces in the response → no baseline lookup, no fire", async () => {
+      getBaselineSpy.mockResolvedValue(buildBaseline({ mean: 20, stddev: 5 }));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+      expect(getBaselineSpy).not.toHaveBeenCalled();
+    });
+
+    test("baseline lookup failure is swallowed (no fire, no throw)", async () => {
+      getBaselineSpy.mockRejectedValue(new Error("clickhouse down"));
+
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.AnomalouslyHigh,
+        value: undefined,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [
+          buildInterface({ name: "Gi0/1", utilizationPercent: 100 }),
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("static threshold path is untouched: GreaterThan still compares numerically", async () => {
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.GreaterThan,
+        value: 80,
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        interfaces: [buildInterface({ name: "Gi0/1", utilizationPercent: 90 })],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeTruthy();
+      expect(getBaselineSpy).not.toHaveBeenCalled();
+    });
+  });
 });