@oneuptime/common 12.0.24 → 12.0.26

package/Tests/Server/Utils/StatusPage/MonitorRulePatternValidator.test.ts

@@ -0,0 +1,62 @@
+import StatusPageMonitorRulePatternValidator from "../../../../Server/Utils/StatusPage/MonitorRulePatternValidator";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Write-time validation for the monitor name/description patterns on status
+ * page monitor rules — the same two syntaxes (case-insensitive regex or '*'
+ * glob) the network-device rules take, and the same refusal for anything that
+ * would compile to a pattern matching nothing (OneUptime/oneuptime#2940).
+ */
+
+describe("StatusPageMonitorRulePatternValidator.validate", () => {
+  test("accepts absent, null and empty patterns", () => {
+    expect(() => {
+      return StatusPageMonitorRulePatternValidator.validate({});
+    }).not.toThrow();
+    expect(() => {
+      return StatusPageMonitorRulePatternValidator.validate({
+        namePattern: null,
+        descriptionPattern: "",
+      });
+    }).not.toThrow();
+  });
+
+  test("accepts a valid regex and a wildcard glob", () => {
+    expect(() => {
+      return StatusPageMonitorRulePatternValidator.validate({
+        namePattern: "api-.*",
+      });
+    }).not.toThrow();
+    expect(() => {
+      return StatusPageMonitorRulePatternValidator.validate({
+        namePattern: "*api*",
+      });
+    }).not.toThrow();
+  });
+
+  test("rejects a name pattern that is neither valid regex nor a glob", () => {
+    let thrown: unknown = null;
+    try {
+      StatusPageMonitorRulePatternValidator.validate({
+        namePattern: "api-(01",
+      });
+    } catch (err: unknown) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(BadDataException);
+    expect((thrown as BadDataException).message).toContain(
+      "Monitor Name Pattern",
+    );
+    expect((thrown as BadDataException).message).toContain("api-(01");
+  });
+
+  test("rejects an invalid description pattern", () => {
+    expect(() => {
+      return StatusPageMonitorRulePatternValidator.validate({
+        descriptionPattern: "[unclosed",
+      });
+    }).toThrow(BadDataException);
+  });
+});

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

@@ -0,0 +1,119 @@
+import StatusPageSubscriberWebhookUtil, {
+  StatusPageWebhookPayload,
+} from "../../../Server/Utils/StatusPageSubscriberWebhook";
+import API from "../../../Utils/API";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import URL from "../../../Types/API/URL";
+import { JSONObject } from "../../../Types/JSON";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import dns from "dns";
+
+/*
+ * The one sink the private-network exception (issue #3424) must never reach.
+ *
+ * Anyone who can load a public status page can register a subscriber with an
+ * arbitrary webhook URL, so relaxing this sink would hand every visitor on the
+ * internet a POST into the operator's private network — regardless of what the
+ * operator configured the exception FOR, which is workflows their own team
+ * wrote.
+ *
+ * The guarantee is structural: the send site passes no options to
+ * SSRFProtection at all, so there is no project to consult and no flag to set.
+ * These tests turn the instance settings all the way up and assert nothing
+ * moves.
+ */
+
+const ALLOW_ENV: string = "ALLOW_PRIVATE_NETWORK_WEBHOOKS";
+const ALLOWLIST_ENV: string = "PRIVATE_NETWORK_WEBHOOK_ALLOWLIST";
+
+describe("Status page subscriber webhooks ignore the private network exception", () => {
+  let postSpy: jest.SpiedFunction<typeof API.post>;
+  let originalAllow: string | undefined;
+  let originalAllowlist: string | undefined;
+
+  const payload: StatusPageWebhookPayload = {
+    eventType: "IncidentCreated",
+    statusPageId: "status-page-id",
+    statusPageName: "Status Page",
+    statusPageUrl: "https://status.example.com",
+    unsubscribeUrl: "https://status.example.com/unsubscribe",
+    data: {},
+  };
+
+  beforeEach(() => {
+    originalAllow = process.env[ALLOW_ENV];
+    originalAllowlist = process.env[ALLOWLIST_ENV];
+
+    // Instance configured as permissively as the feature allows.
+    process.env[ALLOW_ENV] = "true";
+    process.env[ALLOWLIST_ENV] =
+      "mattermost.internal, 10.0.0.0/8, 127.0.0.1, *.svc.cluster.local";
+
+    jest
+      .spyOn(dns.promises, "lookup")
+      .mockResolvedValue([{ address: "10.1.2.3", family: 4 }] as never);
+
+    postSpy = jest
+      .spyOn(API, "post")
+      .mockResolvedValue(
+        new HTTPResponse<JSONObject>(200, {}, {}) as never,
+      ) as unknown as jest.SpiedFunction<typeof API.post>;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+
+    if (originalAllow === undefined) {
+      delete process.env[ALLOW_ENV];
+    } else {
+      process.env[ALLOW_ENV] = originalAllow;
+    }
+
+    if (originalAllowlist === undefined) {
+      delete process.env[ALLOWLIST_ENV];
+    } else {
+      process.env[ALLOWLIST_ENV] = originalAllowlist;
+    }
+  });
+
+  test.each([
+    "http://10.0.0.5/subscriber-hook",
+    "http://192.168.1.10/subscriber-hook",
+    "http://127.0.0.1:9000/subscriber-hook",
+    "http://mattermost.internal/hooks/abc",
+    "http://mattermost.svc.cluster.local/hooks/abc",
+    "http://169.254.169.254/latest/meta-data/",
+  ])("refuses %s and never issues the request", async (url: string) => {
+    const result: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await StatusPageSubscriberWebhookUtil.sendWebhookNotification({
+        webhookUrl: URL.fromString(url),
+        payload,
+      });
+
+    expect(result).toBeInstanceOf(HTTPErrorResponse);
+    expect(postSpy).not.toHaveBeenCalled();
+  });
+
+  test("still sends to a public target", async () => {
+    jest
+      .spyOn(dns.promises, "lookup")
+      .mockResolvedValue([{ address: "93.184.216.34", family: 4 }] as never);
+
+    const result: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await StatusPageSubscriberWebhookUtil.sendWebhookNotification({
+        webhookUrl: URL.fromString("https://hooks.example.com/subscriber"),
+        payload,
+      });
+
+    expect(result).toBeInstanceOf(HTTPResponse);
+    expect(postSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/Tests/Server/Utils/Telemetry/LlmCostBudgetEvaluator.test.ts

@@ -19,6 +19,7 @@ import LlmCostBudgetService from "../../../../Server/Services/LlmCostBudgetServi
 import MetricService from "../../../../Server/Services/MetricService";
 import SpanService from "../../../../Server/Services/SpanService";
 import TelemetryUtil from "../../../../Server/Utils/Telemetry/Telemetry";
+import { LlmMicroUsdCostMetricNames } from "../../../../Types/Telemetry/LlmMetricConventions";
 import { LlmMetricScope } from "../../../../Utils/Telemetry/LlmMetricQuery";
 /*
  * `jest` deliberately comes from the global scope, not @jest/globals — the
@@ -84,6 +85,34 @@ const mockedMetricService: {
   aggregateBy: MockedFn;
 };
 
+/*
+ * Metric-sourced cost is TWO aggregates, not one: the USD-denominated metric
+ * names and the micro-USD ones (the Codex CLI reports millionths of a dollar)
+ * are queried separately and scaled before being added, because a single Sum
+ * over both units cannot be un-mixed afterwards. A plain mockResolvedValue
+ * answers BOTH queries with the same payload, which would feed the same
+ * figure in twice — once at 1e-6 — and quietly skew every expectation here.
+ *
+ * So the mock dispatches on the metric names the query actually selects: the
+ * rows are the project's USD spend, and the micro-USD query correctly finds
+ * nothing.
+ */
+function mockUsdMetricRows(rows: Array<JSONObject>): void {
+  mockedMetricService.aggregateBy.mockImplementation(
+    (aggregate: { query: Record<string, unknown> }): Promise<JSONObject> => {
+      const names: Array<string> = ((
+        aggregate?.query?.["name"] as { values?: Array<string> } | undefined
+      )?.values || []) as Array<string>;
+
+      const isMicroUsd: boolean = names.some((name: string) => {
+        return LlmMicroUsdCostMetricNames.includes(name);
+      });
+
+      return Promise.resolve({ data: isMicroUsd ? [] : rows });
+    },
+  );
+}
+
 const mockedBudgetService: {
   findBy: MockedFn;
   updateOneById: MockedFn;
@@ -596,9 +625,7 @@ describe("LlmCostBudgetEvaluator.resolveSpend — source selection", () => {
   }
 
   function mockMetricSpend(value: number): void {
-    mockedMetricService.aggregateBy.mockResolvedValue({
-      data: [{ timestamp: NOW, value: value }],
-    } as never);
+    mockUsdMetricRows([{ timestamp: NOW, value: value }]);
   }
 
   test("uses spans when the span stream reported spend", async () => {
@@ -730,12 +757,10 @@ describe("LlmCostBudgetEvaluator.resolveSpend — source selection", () => {
   });
 
   test("sums multiple metric buckets", async () => {
-    mockedMetricService.aggregateBy.mockResolvedValue({
-      data: [
-        { timestamp: NOW, value: 1.5 },
-        { timestamp: NOW, value: 2.5 },
-      ],
-    } as never);
+    mockUsdMetricRows([
+      { timestamp: NOW, value: 1.5 },
+      { timestamp: NOW, value: 2.5 },
+    ]);
 
     await expect(
       LlmCostBudgetEvaluator.resolveSpend({
@@ -781,9 +806,7 @@ describe("LlmCostBudgetEvaluator.evaluateBudget — metric-sourced spend", () =>
   });
 
   test("a metrics-only project gets its spend stamped on the budget row", async () => {
-    mockedMetricService.aggregateBy.mockResolvedValue({
-      data: [{ timestamp: NOW, value: 60 }],
-    } as never);
+    mockUsdMetricRows([{ timestamp: NOW, value: 60 }]);
 
     const budget: LlmCostBudget = makeBudget({ dailyBudgetInUSD: 100 });
 
@@ -798,9 +821,7 @@ describe("LlmCostBudgetEvaluator.evaluateBudget — metric-sourced spend", () =>
   });
 
   test("a metrics-only project publishes the same budget series as a span-backed one", async () => {
-    mockedMetricService.aggregateBy.mockResolvedValue({
-      data: [{ timestamp: NOW, value: 80 }],
-    } as never);
+    mockUsdMetricRows([{ timestamp: NOW, value: 80 }]);
 
     await LlmCostBudgetEvaluator.evaluateBudget({
       budget: makeBudget({ dailyBudgetInUSD: 100 }),
@@ -823,9 +844,7 @@ describe("LlmCostBudgetEvaluator.evaluateBudget — metric-sourced spend", () =>
    * have to learn about the source.
    */
   test("the published series carries no source-specific attribute", async () => {
-    mockedMetricService.aggregateBy.mockResolvedValue({
-      data: [{ timestamp: NOW, value: 5 }],
-    } as never);
+    mockUsdMetricRows([{ timestamp: NOW, value: 5 }]);
 
     const budget: LlmCostBudget = makeBudget();
 

package/Tests/Server/Utils/Telemetry/LlmMetricSpend.test.ts

@@ -5,6 +5,7 @@ import Includes from "../../../../Types/BaseDatabase/Includes";
 import ObjectID from "../../../../Types/ObjectID";
 import {
   LlmCostMetricNames,
+  LlmMicroUsdCostMetricNames,
   LlmTokenTypeAttributeKeys,
   LlmTokenUsageMetricNames,
 } from "../../../../Types/Telemetry/LlmMetricConventions";
@@ -111,6 +112,65 @@ describe("LlmMetricSpend", () => {
     });
   });
 
+  /*
+   * The micro-USD aggregate. It exists as a SECOND query for one reason: the
+   * recognized cost metrics come in two units, and a single Sum over both
+   * would add millionths of a dollar to dollars with no way to recover the
+   * unit afterwards. A $3 Codex turn would reach a budget as $3,000,000.
+   */
+  describe("buildMicroUsdCostAggregateBy", () => {
+    test("selects the micro-USD metric names", () => {
+      const query: Record<string, unknown> =
+        LlmMetricSpend.buildMicroUsdCostAggregateBy(scope())
+          .query as unknown as Record<string, unknown>;
+
+      expect((query["name"] as Includes).values).toEqual(
+        LlmMicroUsdCostMetricNames,
+      );
+    });
+
+    test("never selects a USD cost metric name", () => {
+      const query: Record<string, unknown> =
+        LlmMetricSpend.buildMicroUsdCostAggregateBy(scope())
+          .query as unknown as Record<string, unknown>;
+
+      const names: Array<string> = (query["name"] as Includes)
+        .values as Array<string>;
+
+      for (const name of names) {
+        expect(LlmCostMetricNames).not.toContain(name);
+      }
+    });
+
+    test("sums the value column over the whole window, like the USD query", () => {
+      const aggregate: AggregateBy<Metric> =
+        LlmMetricSpend.buildMicroUsdCostAggregateBy(scope());
+
+      expect(aggregate.aggregationType).toBe(AggregationType.Sum);
+      expect(aggregate.aggregateColumnName).toBe("value");
+      expect(aggregate.aggregationInterval).toBe(AggregationInterval.Total);
+      expect(aggregate.startTimestamp).toBe(START);
+      expect(aggregate.endTimestamp).toBe(END);
+    });
+
+    test("fails loud on query timeout", () => {
+      expect(
+        LlmMetricSpend.buildMicroUsdCostAggregateBy(scope())
+          .timeoutOverflowMode,
+      ).toBe("throw");
+    });
+
+    test("carries the caller's scoping into the query", () => {
+      const query: Record<string, unknown> =
+        LlmMetricSpend.buildMicroUsdCostAggregateBy(
+          scope({ serviceId: SERVICE_ID, llmSystem: "openai" }),
+        ).query as unknown as Record<string, unknown>;
+
+      expect(query["primaryEntityId"]).toBe(SERVICE_ID);
+      expect(query["attributes"]).toEqual({ "gen_ai.system": "openai" });
+    });
+  });
+
   describe("buildTokenAggregateBy", () => {
     test("selects the token usage metric names", () => {
       const query: Record<string, unknown> =
@@ -185,12 +245,93 @@ describe("LlmMetricSpend", () => {
       );
     });
 
-    test("issues exactly one aggregate", async () => {
+    /*
+     * TWO aggregates, not one — this count changed deliberately when the
+     * micro-USD emitters (the Codex CLI) were recognized. The two name lists
+     * carry different UNITS, so they cannot share a Sum; see
+     * buildMicroUsdCostAggregateBy above.
+     */
+    test("issues one aggregate per cost unit", async () => {
       mockedMetricService.aggregateBy.mockResolvedValue({ data: [] });
 
       await LlmMetricSpend.getCostInUSD(scope());
 
-      expect(mockedMetricService.aggregateBy).toHaveBeenCalledTimes(1);
+      expect(mockedMetricService.aggregateBy).toHaveBeenCalledTimes(2);
+    });
+
+    test("the two cost aggregates select disjoint metric names", async () => {
+      mockedMetricService.aggregateBy.mockResolvedValue({ data: [] });
+
+      await LlmMetricSpend.getCostInUSD(scope());
+
+      const selected: Array<Array<string>> =
+        mockedMetricService.aggregateBy.mock.calls.map(
+          (call: Array<unknown>): Array<string> => {
+            const aggregate: AggregateBy<Metric> =
+              call[0] as AggregateBy<Metric>;
+            const query: Record<string, unknown> =
+              aggregate.query as unknown as Record<string, unknown>;
+
+            return (query["name"] as Includes).values as Array<string>;
+          },
+        );
+
+      expect(selected).toHaveLength(2);
+      expect(selected[0]).toEqual(LlmCostMetricNames);
+      expect(selected[1]).toEqual(LlmMicroUsdCostMetricNames);
+
+      const overlap: Array<string> = selected[0]!.filter((name: string) => {
+        return selected[1]!.includes(name);
+      });
+
+      expect(overlap).toEqual([]);
+    });
+
+    /*
+     * The million-fold regression, end to end: a Codex turn reported as
+     * 1,500,000 micro-USD must reach a budget as $1.50, not $1,500,000.
+     */
+    test("scales micro-USD spend by 1e-6 before adding it to USD spend", async () => {
+      mockedMetricService.aggregateBy
+        .mockResolvedValueOnce({ data: [{ timestamp: START, value: 0.5 }] })
+        .mockResolvedValueOnce({
+          data: [{ timestamp: START, value: 1_500_000 }],
+        });
+
+      await expect(LlmMetricSpend.getCostInUSD(scope())).resolves.toBeCloseTo(
+        2,
+        10,
+      );
+    });
+
+    test("micro-USD-only spend is still reported rather than lost", async () => {
+      // The metrics-only Codex fleet: no USD cost metric exists at all.
+      mockedMetricService.aggregateBy
+        .mockResolvedValueOnce({ data: [] })
+        .mockResolvedValueOnce({
+          data: [{ timestamp: START, value: 2_250_000 }],
+        });
+
+      await expect(LlmMetricSpend.getCostInUSD(scope())).resolves.toBeCloseTo(
+        2.25,
+        10,
+      );
+    });
+
+    test("a micro-USD query failure is not swallowed into a low total", async () => {
+      /*
+       * Both aggregates run in parallel; a failure in EITHER must propagate.
+       * Silently treating the failed one as zero would understate spend and
+       * suppress a real budget breach — the same reasoning as the
+       * timeoutOverflowMode: "throw" above.
+       */
+      mockedMetricService.aggregateBy
+        .mockResolvedValueOnce({ data: [{ timestamp: START, value: 1 }] })
+        .mockRejectedValueOnce(new Error("clickhouse timeout"));
+
+      await expect(LlmMetricSpend.getCostInUSD(scope())).rejects.toThrow(
+        "clickhouse timeout",
+      );
     });
   });