@oneuptime/common 11.5.4 → 11.5.6

package/Server/Utils/Monitor/MonitorCriteriaObservationBuilder.ts

@@ -1169,8 +1169,25 @@ export default class MonitorCriteriaObservationBuilder {
         alias: metricValues.alias,
       });
 
+    /*
+     * The display values are expressed in the threshold's unit (or the
+     * metric's native/legend unit when no threshold unit was set). Surface
+     * that unit alongside the numbers so the message reads "latest 0.06 sec"
+     * instead of the unitless "latest 0.06".
+     */
+    const displayUnit: string | undefined =
+      MonitorCriteriaObservationBuilder.resolveMetricUnits({
+        criteriaFilter: input.criteriaFilter,
+        dataToProcess: input.dataToProcess,
+        monitorStep: input.monitorStep,
+        alias: metricValues.alias,
+      }).displayUnit;
+
     const summary: string | null =
-      MonitorCriteriaMessageFormatter.summarizeNumericSeries(displayValues);
+      MonitorCriteriaMessageFormatter.summarizeNumericSeries(
+        displayValues,
+        displayUnit,
+      );
 
     if (!summary) {
       return null;
@@ -1195,18 +1212,67 @@ export default class MonitorCriteriaObservationBuilder {
     monitorStep: MonitorStep;
     alias: string | null;
   }): Array<number> {
-    const thresholdUnit: string | undefined =
-      input.criteriaFilter.metricMonitorOptions?.thresholdUnit;
+    const { sampleUnit, thresholdUnit } =
+      MonitorCriteriaObservationBuilder.resolveMetricUnits({
+        criteriaFilter: input.criteriaFilter,
+        dataToProcess: input.dataToProcess,
+        monitorStep: input.monitorStep,
+        alias: input.alias,
+      });
+
     if (!thresholdUnit) {
       return input.values;
     }
 
+    if (!sampleUnit || sampleUnit === thresholdUnit) {
+      return input.values;
+    }
+
+    return input.values.map((v: number) => {
+      return MetricUnitUtil.convertToMetricUnit({
+        value: v,
+        fromUnit: sampleUnit,
+        metricUnit: thresholdUnit,
+      });
+    });
+  }
+
+  /*
+   * Resolve the units involved in a metric-value observation:
+   *   - sampleUnit:    the unit the raw samples arrive in (legendUnit, or
+   *                    the metric's native unit when no legend was set).
+   *   - thresholdUnit: the unit the user entered the threshold in, if any.
+   *   - displayUnit:   the unit the rendered numbers (samples + threshold)
+   *                    are actually expressed in. This mirrors the
+   *                    MetricMonitorCriteria evaluator: the threshold unit
+   *                    wins when present (samples are converted into it),
+   *                    otherwise the samples stay in their native unit.
+   * Every field is best-effort — undefined when the metric response or
+   * config isn't available. Never throws.
+   */
+  private static resolveMetricUnits(input: {
+    criteriaFilter: CriteriaFilter;
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    alias: string | null;
+  }): {
+    sampleUnit: string | undefined;
+    thresholdUnit: string | undefined;
+    displayUnit: string | undefined;
+  } {
+    const thresholdUnit: string | undefined =
+      input.criteriaFilter.metricMonitorOptions?.thresholdUnit || undefined;
+
     const metricResponse: MetricMonitorResponse | null =
       MonitorCriteriaDataExtractor.getMetricMonitorResponse(
         input.dataToProcess,
       );
     if (!metricResponse) {
-      return input.values;
+      return {
+        sampleUnit: undefined,
+        thresholdUnit,
+        displayUnit: thresholdUnit,
+      };
     }
 
     const metricViewConfig: MetricsViewConfig | undefined =
@@ -1244,17 +1310,69 @@ export default class MonitorCriteriaObservationBuilder {
       nativeUnitFromMap ||
       undefined;
 
-    if (!sampleUnit || sampleUnit === thresholdUnit) {
-      return input.values;
+    return {
+      sampleUnit,
+      thresholdUnit,
+      displayUnit: MonitorCriteriaObservationBuilder.normalizeDisplayUnit(
+        thresholdUnit || sampleUnit,
+      ),
+    };
+  }
+
+  /*
+   * Suppress units that would read as noise next to a raw number. OTel's
+   * dimensionless "1" marks ratio metrics whose samples are fractions in
+   * [0, 1]; rendering "0.06 1" is both ugly and misleading (it is not 1% —
+   * it is 6%). Returning undefined leaves the number unlabelled, matching
+   * the pre-unit behavior for that specific case. Any real unit passes
+   * through unchanged.
+   */
+  private static normalizeDisplayUnit(
+    unit: string | undefined,
+  ): string | undefined {
+    if (!unit || !unit.trim()) {
+      return undefined;
     }
 
-    return input.values.map((v: number) => {
-      return MetricUnitUtil.convertToMetricUnit({
-        value: v,
-        fromUnit: sampleUnit,
-        metricUnit: thresholdUnit,
-      });
+    if (unit.trim() === "1") {
+      return undefined;
+    }
+
+    return unit;
+  }
+
+  /*
+   * Public accessor for the unit that a metric-value criteria's observed
+   * samples and threshold are displayed in. Returns undefined for
+   * non-metric criteria or when no unit can be resolved, so callers can
+   * safely append it as a suffix. Used by the message builder to label the
+   * threshold in the "expected to be greater than 5 sec" clause so it
+   * matches the "recorded latest 0.06 sec" observation.
+   */
+  public static getMetricValueDisplayUnit(input: {
+    criteriaFilter: CriteriaFilter;
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+  }): string | undefined {
+    if (input.criteriaFilter.checkOn !== CheckOn.MetricValue) {
+      return undefined;
+    }
+
+    const metricValues: {
+      alias: string | null;
+      values: Array<number>;
+    } | null = MonitorCriteriaDataExtractor.extractMetricValues({
+      criteriaFilter: input.criteriaFilter,
+      dataToProcess: input.dataToProcess,
+      monitorStep: input.monitorStep,
     });
+
+    return MonitorCriteriaObservationBuilder.resolveMetricUnits({
+      criteriaFilter: input.criteriaFilter,
+      dataToProcess: input.dataToProcess,
+      monitorStep: input.monitorStep,
+      alias: metricValues?.alias ?? null,
+    }).displayUnit;
   }
 
   private static getSnmpResponse(input: {

package/Tests/Server/Infrastructure/Queue.test.ts

@@ -0,0 +1,227 @@
+import Queue, { QueueName } from "../../../Server/Infrastructure/Queue";
+import { RepeatableJob } from "bullmq";
+
+jest.mock("../../../Server/Infrastructure/Redis", () => {
+  return {
+    __esModule: true,
+    default: {
+      getRedisOptions: jest.fn().mockReturnValue({}),
+    },
+  };
+});
+
+type MockBullQueue = {
+  getRepeatableJobs: jest.Mock;
+  removeRepeatableByKey: jest.Mock;
+  getJob: jest.Mock;
+  clean: jest.Mock;
+  add: jest.Mock;
+  client: Promise<{ on: jest.Mock }>;
+};
+
+/*
+ * Must be prefixed with "mock" — jest.mock() factories are hoisted and may not
+ * reference out-of-scope variables that aren't so named.
+ */
+const mockBullQueueInstances: Array<MockBullQueue> = [];
+
+jest.mock("bullmq", () => {
+  return {
+    __esModule: true,
+    Queue: jest.fn().mockImplementation(() => {
+      const instance: MockBullQueue = {
+        getRepeatableJobs: jest.fn().mockResolvedValue([]),
+        removeRepeatableByKey: jest.fn().mockResolvedValue(true),
+        getJob: jest.fn().mockResolvedValue(undefined),
+        clean: jest.fn().mockResolvedValue([]),
+        add: jest.fn().mockResolvedValue({}),
+        client: Promise.resolve({ on: jest.fn() }),
+      };
+      mockBullQueueInstances.push(instance);
+      return instance;
+    }),
+  };
+});
+
+/*
+ * Builds a RepeatableJob as BullMQ returns it: `key` is the opaque md5 zset
+ * member, and is the ONLY thing removeRepeatableByKey() accepts.
+ */
+const repeatable: (name: string, key: string) => RepeatableJob = (
+  name: string,
+  key: string,
+): RepeatableJob => {
+  return {
+    key: key,
+    name: name,
+    id: null,
+    endDate: null,
+    tz: null,
+    pattern: "*/15 * * * *",
+  };
+};
+
+describe("Queue.removeRepeatableByName", () => {
+  let queue: MockBullQueue;
+
+  beforeAll(() => {
+    // Force the (cached) BullQueue for the Worker queue to be constructed.
+    Queue.getQueue(QueueName.Worker);
+    queue = mockBullQueueInstances[0] as MockBullQueue;
+  });
+
+  beforeEach(() => {
+    queue.getRepeatableJobs.mockReset().mockResolvedValue([]);
+    queue.removeRepeatableByKey.mockReset().mockResolvedValue(true);
+  });
+
+  /*
+   * The whole point of the method: go from a job NAME to the opaque repeat KEY.
+   * A renamed cron (e.g. SentinelInsight:ScanForInsights ->
+   * AIInsight:ScanForInsights) leaves its old repeatable behind in Redis,
+   * firing forever, and the name is all we have to find it by.
+   */
+  it("removes a repeatable whose name matches, using its key", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("AIInsight:ScanForInsights", "aaaaaaaaaaaaaaaa"),
+      repeatable("SentinelInsight:ScanForInsights", "86b9a73a59ccbe97264b573"),
+    ]);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(1);
+    expect(queue.removeRepeatableByKey).toHaveBeenCalledTimes(1);
+    expect(queue.removeRepeatableByKey).toHaveBeenCalledWith(
+      "86b9a73a59ccbe97264b573",
+    );
+  });
+
+  /*
+   * Regression guard for the trap this method exists to avoid: BullMQ's
+   * removeRepeatableByKey() ZREMs the exact member it is given, so passing a
+   * job NAME (or a job id derived from it) matches nothing and silently
+   * no-ops. The key must be the one from getRepeatableJobs().
+   */
+  it("never passes the job name to removeRepeatableByKey", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("SentinelInsight:ScanForInsights", "86b9a73a59ccbe97264b573"),
+    ]);
+
+    await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(queue.removeRepeatableByKey).not.toHaveBeenCalledWith(
+      "SentinelInsight:ScanForInsights",
+    );
+    // ...nor the ":"-sanitized form that Queue.removeJob() would have used.
+    expect(queue.removeRepeatableByKey).not.toHaveBeenCalledWith(
+      "SentinelInsight-ScanForInsights",
+    );
+  });
+
+  it("removes every repeatable sharing the name and returns the count", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("SentinelInsight:ScanForInsights", "key-one"),
+      repeatable("SomeOther:Job", "key-two"),
+      repeatable("SentinelInsight:ScanForInsights", "key-three"),
+    ]);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(2);
+    expect(
+      queue.removeRepeatableByKey.mock.calls.map((c: Array<string>) => {
+        return c[0];
+      }),
+    ).toEqual(["key-one", "key-three"]);
+  });
+
+  /*
+   * Idempotence is what lets this run on EVERY worker boot: once the legacy
+   * repeatable is gone (or on a fresh install that never had it), the sweep
+   * must be a cheap no-op rather than an error.
+   */
+  it("is a no-op when no repeatable has that name", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("AIInsight:ScanForInsights", "aaaaaaaaaaaaaaaa"),
+    ]);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(0);
+    expect(queue.removeRepeatableByKey).not.toHaveBeenCalled();
+  });
+
+  it("does not count a repeatable BullMQ reported as not removed", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("SentinelInsight:ScanForInsights", "key-one"),
+    ]);
+    // BullMQ returns false when the key was already gone from the repeat zset.
+    queue.removeRepeatableByKey.mockResolvedValue(false);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(0);
+  });
+
+  it("skips the Redis round trip when the name is empty", async () => {
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "",
+    );
+
+    expect(removedCount).toBe(0);
+    expect(queue.getRepeatableJobs).not.toHaveBeenCalled();
+  });
+});
+
+describe("Queue.removeJob", () => {
+  let queue: MockBullQueue;
+
+  beforeAll(() => {
+    Queue.getQueue(QueueName.Worker);
+    queue = mockBullQueueInstances[0] as MockBullQueue;
+  });
+
+  beforeEach(() => {
+    queue.getJob.mockReset().mockResolvedValue(undefined);
+    queue.removeRepeatableByKey.mockReset().mockResolvedValue(true);
+  });
+
+  /*
+   * The repeat key is NOT a job id: it is either an md5 or a legacy
+   * "name:id:endDate:tz:pattern" string. Sanitizing ":" -> "-" (which the job
+   * id lookup must do, since BullMQ rejects colons in custom ids) would mangle
+   * the legacy form into a zset member that does not exist, and the removal
+   * would silently no-op. QueueWorkflow passes job.repeatJobKey straight in
+   * here, so the raw value has to survive.
+   */
+  it("passes the repeat key through unsanitized", async () => {
+    await Queue.removeJob(QueueName.Worker, "myjob:someid:0::*/5 * * * *");
+
+    expect(queue.removeRepeatableByKey).toHaveBeenCalledWith(
+      "myjob:someid:0::*/5 * * * *",
+    );
+  });
+
+  // The job-id lookup, by contrast, must use the sanitized id.
+  it("looks the one-off job up by its sanitized id", async () => {
+    await Queue.removeJob(QueueName.Worker, "myjob:someid");
+
+    expect(queue.getJob).toHaveBeenCalledWith("myjob-someid");
+  });
+});

package/Tests/Server/Infrastructure/SemaphorePermit.test.ts

@@ -0,0 +1,159 @@
+import Redis, { ClientType } from "../../../Server/Infrastructure/Redis";
+import Semaphore, {
+  SemaphorePermit,
+} from "../../../Server/Infrastructure/Semaphore";
+import { Semaphore as RedisSemaphore } from "redis-semaphore";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+interface MockPermit {
+  acquire: jest.Mock;
+  release: jest.Mock;
+}
+
+jest.mock("redis-semaphore", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "redis-semaphore",
+  ) as Record<string, unknown>;
+
+  return {
+    ...actual,
+    Semaphore: jest.fn().mockImplementation((): MockPermit => {
+      return {
+        acquire: jest.fn(async (): Promise<void> => {}),
+        release: jest.fn(async (): Promise<void> => {}),
+      };
+    }),
+  };
+});
+
+const redisSemaphoreConstructor: jest.MockedClass<typeof RedisSemaphore> =
+  RedisSemaphore as jest.MockedClass<typeof RedisSemaphore>;
+
+function mockRedisClient(): ClientType {
+  const client: ClientType = {} as ClientType;
+  jest.spyOn(Redis, "getClient").mockReturnValue(client);
+  return client;
+}
+
+function lastMockPermit(): MockPermit {
+  const result: unknown = redisSemaphoreConstructor.mock.results.at(-1)?.value;
+  return result as MockPermit;
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  redisSemaphoreConstructor.mockClear();
+});
+
+describe("Semaphore distributed permits", () => {
+  test("constructs and acquires a fixed-size project pool with all options", async () => {
+    const client: ClientType = mockRedisClient();
+
+    const permit: SemaphorePermit = await Semaphore.acquirePermit({
+      key: "project-1",
+      namespace: "workflow-ai",
+      limit: 3,
+      lockTimeout: 65_000,
+      acquireTimeout: 250,
+      acquireAttemptsLimit: 1,
+      retryInterval: 50,
+    });
+
+    expect(redisSemaphoreConstructor).toHaveBeenCalledWith(
+      client,
+      "workflow-ai-project-1",
+      3,
+      {
+        lockTimeout: 65_000,
+        acquireTimeout: 250,
+        acquireAttemptsLimit: 1,
+        retryInterval: 50,
+      },
+    );
+    expect(lastMockPermit().acquire).toHaveBeenCalledTimes(1);
+    expect(permit).toBe(lastMockPermit());
+  });
+
+  test("uses the existing five-second lock default when none is supplied", async () => {
+    mockRedisClient();
+
+    await Semaphore.acquirePermit({
+      key: "project-1",
+      namespace: "workflow-ai",
+      limit: 3,
+    });
+
+    expect(redisSemaphoreConstructor).toHaveBeenCalledWith(
+      expect.anything(),
+      "workflow-ai-project-1",
+      3,
+      { lockTimeout: 5_000 },
+    );
+  });
+
+  test.each([0, -1, 1.5])(
+    "rejects invalid permit limit %p",
+    async (limit: number) => {
+      const getClient: jest.SpyInstance = jest.spyOn(Redis, "getClient");
+
+      await expect(
+        Semaphore.acquirePermit({
+          key: "project-1",
+          namespace: "workflow-ai",
+          limit,
+        }),
+      ).rejects.toThrow(/positive integer/i);
+
+      expect(getClient).not.toHaveBeenCalled();
+      expect(redisSemaphoreConstructor).not.toHaveBeenCalled();
+    },
+  );
+
+  test("rejects when Redis is not connected", async () => {
+    jest.spyOn(Redis, "getClient").mockReturnValue(null);
+
+    await expect(
+      Semaphore.acquirePermit({
+        key: "project-1",
+        namespace: "workflow-ai",
+        limit: 3,
+      }),
+    ).rejects.toThrow(/Redis client is not connected/i);
+
+    expect(redisSemaphoreConstructor).not.toHaveBeenCalled();
+  });
+
+  test("propagates acquisition failures without returning an unheld permit", async () => {
+    mockRedisClient();
+    const acquireError: Error = new Error("pool is full");
+    redisSemaphoreConstructor.mockImplementationOnce(() => {
+      return {
+        acquire: jest.fn(async (): Promise<void> => {
+          throw acquireError;
+        }),
+        release: jest.fn(async (): Promise<void> => {}),
+      } as unknown as RedisSemaphore;
+    });
+
+    await expect(
+      Semaphore.acquirePermit({
+        key: "project-1",
+        namespace: "workflow-ai",
+        limit: 3,
+      }),
+    ).rejects.toBe(acquireError);
+  });
+
+  test("releases the exact acquired permit", async () => {
+    mockRedisClient();
+    const permit: SemaphorePermit = await Semaphore.acquirePermit({
+      key: "project-1",
+      namespace: "workflow-ai",
+      limit: 3,
+    });
+
+    await Semaphore.releasePermit(permit);
+
+    expect(lastMockPermit().release).toHaveBeenCalledTimes(1);
+  });
+});