@oneuptime/common 12.0.30 → 12.0.32

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

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+import ObjectID from "../../../Types/ObjectID";
+import API from "../../../Utils/API";
+import ClusterKeyAuthorization from "../../../Server/Middleware/ClusterKeyAuthorization";
+import logger from "../../../Server/Utils/Logger";
+import releaseIncomingCallPhoneNumber from "../../../Server/Utils/IncomingCallPhoneNumber";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * Releasing a provisioned incoming-call number when its config is deleted.
+ *
+ * The Common layer cannot reach the call provider itself, so this hands the
+ * release to the notification app's internal endpoint. It runs during cleanup,
+ * behind a delete the user has already asked for, and its whole contract is
+ * that it FAILS OPEN: the provider being unreachable, the notification app
+ * being mid-restart, or the endpoint answering 500 must all leave the parent
+ * delete to finish. A throw escaping here would leave the user's config
+ * undeletable for as long as the provider is unwell.
+ *
+ * The endpoint is internal and authenticated by cluster key rather than by a
+ * user, so the header is not optional decoration — a request without it is
+ * rejected and the number silently stays provisioned, which is a bill the
+ * project keeps paying for something it deleted.
+ */
+
+jest.mock("../../../Utils/API", () => {
+  return { __esModule: true, default: { post: jest.fn() } };
+});
+
+jest.mock("../../../Server/Middleware/ClusterKeyAuthorization", () => {
+  return {
+    __esModule: true,
+    default: { getClusterKeyHeaders: jest.fn() },
+  };
+});
+
+jest.mock("../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+    },
+  };
+});
+
+const api: { post: jest.Mock } = API as unknown as { post: jest.Mock };
+
+const clusterKey: { getClusterKeyHeaders: jest.Mock } =
+  ClusterKeyAuthorization as unknown as {
+    getClusterKeyHeaders: jest.Mock;
+  };
+
+const mockedLogger: { error: jest.Mock } = logger as unknown as {
+  error: jest.Mock;
+};
+
+const CONFIG_ID: ObjectID = ObjectID.generate();
+const PROVIDER_NUMBER_ID: string = "PN_provider_abc123";
+
+function callArgs(): JSONObject {
+  return api.post.mock.calls[0]![0] as JSONObject;
+}
+
+function release(): Promise<void> {
+  return releaseIncomingCallPhoneNumber({
+    projectCallSMSConfigId: CONFIG_ID,
+    callProviderPhoneNumberId: PROVIDER_NUMBER_ID,
+  });
+}
+
+describe("releaseIncomingCallPhoneNumber", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    api.post.mockResolvedValue(undefined as never);
+    clusterKey.getClusterKeyHeaders.mockReturnValue({
+      clusterkey: "test-cluster-key",
+    });
+  });
+
+  describe("the request it makes", () => {
+    test("posts to the notification app's internal release endpoint", async () => {
+      await release();
+
+      expect(api.post).toHaveBeenCalledTimes(1);
+      expect(callArgs()["url"]!.toString()).toContain(
+        "/api/notification/phone-number/internal/release",
+      );
+    });
+
+    /*
+     * Both ids are needed: the provider's own id says which number to hand
+     * back, and the config id is what the endpoint authorises the release
+     * against. Dropping either silently leaves the number provisioned.
+     */
+    test("names both the config and the provider's number", async () => {
+      await release();
+
+      const data: JSONObject = callArgs()["data"] as JSONObject;
+
+      expect(data["projectCallSMSConfigId"]).toBe(CONFIG_ID.toString());
+      expect(data["callProviderPhoneNumberId"]).toBe(PROVIDER_NUMBER_ID);
+    });
+
+    /*
+     * The id is sent as its string form, not as an ObjectID that would
+     * serialize to whatever JSON.stringify makes of the instance.
+     */
+    test("the config id is sent as a plain string", async () => {
+      await release();
+
+      expect(
+        typeof (callArgs()["data"] as JSONObject)["projectCallSMSConfigId"],
+      ).toBe("string");
+    });
+
+    /*
+     * An internal endpoint with no user behind it. Without the cluster key the
+     * request is rejected and the number stays provisioned - and because this
+     * function swallows failures, that rejection would be invisible.
+     */
+    test("carries the cluster key the internal endpoint authenticates on", async () => {
+      await release();
+
+      expect(clusterKey.getClusterKeyHeaders).toHaveBeenCalled();
+      expect((callArgs()["headers"] as JSONObject)["clusterkey"]).toBe(
+        "test-cluster-key",
+      );
+    });
+  });
+
+  describe("it fails open, so cleanup never blocks the delete", () => {
+    /*
+     * The parent delete has already been asked for. A provider or network
+     * problem during cleanup must not resurrect the row the user deleted.
+     */
+    test("a rejected request resolves rather than throwing", async () => {
+      api.post.mockRejectedValue(new Error("provider unreachable") as never);
+
+      await expect(release()).resolves.toBeUndefined();
+    });
+
+    test("the failure is logged rather than swallowed silently", async () => {
+      api.post.mockRejectedValue(new Error("provider unreachable") as never);
+
+      await release();
+
+      expect(mockedLogger.error).toHaveBeenCalled();
+    });
+
+    /*
+     * A synchronous throw while the request is still being assembled - a
+     * missing cluster key secret, say - is the same kind of cleanup failure
+     * and must not escape either.
+     */
+    test("a throw while building the request is caught too", async () => {
+      clusterKey.getClusterKeyHeaders.mockImplementation((): never => {
+        throw new Error("no cluster key configured");
+      });
+
+      await expect(release()).resolves.toBeUndefined();
+      expect(mockedLogger.error).toHaveBeenCalled();
+      expect(api.post).not.toHaveBeenCalled();
+    });
+
+    test("a successful release logs no error", async () => {
+      await release();
+
+      expect(mockedLogger.error).not.toHaveBeenCalled();
+    });
+  });
+});

package/Tests/Server/Utils/Monitor/CapturedMetricAttributeUtil.test.ts

@@ -0,0 +1,284 @@
+import CapturedMetricAttributeUtil, {
+  MaxCapturedMetricAttributes,
+  MaxCapturedMetricAttributeKeyLength,
+  MaxCapturedMetricAttributeValueLength,
+  SanitizedCapturedMetricAttributes,
+} from "../../../../Server/Utils/Monitor/CapturedMetricAttributeUtil";
+import {
+  AllResourceIdentityLabelKeys,
+  ServiceNameLabelKeys,
+} from "../../../../Server/Utils/Monitor/SeriesResourceLabels";
+import { JSONObject } from "../../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The guard in front of the ONE metric writer whose attribute KEYS are user
+ * input: `oneuptime.captureMetric(name, value, attributes)` inside a custom
+ * code or synthetic monitor script.
+ *
+ * The stakes are not cosmetic. An attribute such as `service.name` is read
+ * back as a claim about which resource the datapoint describes: Service >
+ * Metrics scopes its charts by the raw `resource.service.name` string, and
+ * once any metric monitor groups by one of these keys it becomes a series
+ * label, from where SeriesResourceLinker attaches the named Service to the
+ * alerts and incidents that series opens, AlertOwnerRuleEngineService pages
+ * that Service's owners, and MonitorMaintenanceSuppression silences the series
+ * for the duration of a maintenance window on it.
+ */
+describe("CapturedMetricAttributeUtil", () => {
+  describe("isReservedAttributeKey", () => {
+    test("refuses every key the series-label resolver treats as resource identity", () => {
+      // Derived from the read side so the two can never disagree.
+      for (const key of AllResourceIdentityLabelKeys) {
+        expect(CapturedMetricAttributeUtil.isReservedAttributeKey(key)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("refuses the monitor's own identity attributes", () => {
+      for (const key of [
+        "monitorId",
+        "projectId",
+        "monitorName",
+        "probeName",
+        "probeId",
+        "isCustomMetric",
+      ]) {
+        expect(CapturedMetricAttributeUtil.isReservedAttributeKey(key)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("refuses the whole oneuptime.* namespace, not just the keys that collide today", () => {
+      for (const key of [
+        "oneuptime.service.id",
+        "oneuptime.host.name",
+        "oneuptime.label.product",
+        "oneuptime.customField.team",
+        "oneuptime.something.invented.later",
+      ]) {
+        expect(CapturedMetricAttributeUtil.isReservedAttributeKey(key)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("refuses the whole resource.* namespace — a monitor metric has no OTel resource", () => {
+      for (const key of [
+        "resource.service.name",
+        "resource.host.name",
+        "resource.telemetry.sdk.language",
+        "resource.anything",
+      ]) {
+        expect(CapturedMetricAttributeUtil.isReservedAttributeKey(key)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("refuses dotted keys whose segments would walk the object prototype", () => {
+      for (const key of [
+        "__proto__",
+        "__proto__.polluted",
+        "constructor.prototype.polluted",
+        "a.__proto__.b",
+        "prototype",
+      ]) {
+        expect(CapturedMetricAttributeUtil.isReservedAttributeKey(key)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("allows ordinary script-chosen dimensions", () => {
+      for (const key of [
+        "region",
+        "environment",
+        "ai.tool",
+        "cursor.team.id",
+        "queue",
+        "service_name",
+        "myservice.name",
+        "serviceName",
+      ]) {
+        expect(CapturedMetricAttributeUtil.isReservedAttributeKey(key)).toBe(
+          false,
+        );
+      }
+    });
+  });
+
+  describe("sanitize", () => {
+    test("keeps ordinary attributes untouched", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          region: "us-east-1",
+          environment: "production",
+          "ai.tool": "cursor",
+        });
+
+      expect(result.attributes).toEqual({
+        region: "us-east-1",
+        environment: "production",
+        "ai.tool": "cursor",
+      });
+      expect(result.droppedReservedKeys).toEqual([]);
+    });
+
+    test("drops every resource-identity spelling of service.name and reports it", () => {
+      const attributes: JSONObject = {};
+      for (const key of ServiceNameLabelKeys) {
+        attributes[key] = "payments-api";
+      }
+      attributes["region"] = "us-east-1";
+
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize(attributes);
+
+      expect(result.attributes).toEqual({ region: "us-east-1" });
+      expect(result.droppedReservedKeys.sort()).toEqual(
+        [...ServiceNameLabelKeys].sort(),
+      );
+    });
+
+    test("drops the host, kubernetes, iot and cluster identity keys too", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          "host.name": "web-01",
+          "oneuptime.host.id": "9c3a0c3e-0000-4000-8000-000000000001",
+          "k8s.cluster.name": "prod",
+          "iot.fleet.name": "fleet-a",
+          "proxmox.cluster.name": "pve",
+          "ceph.cluster.name": "ceph",
+          "docker.swarm.cluster.name": "swarm",
+          keep: "yes",
+        });
+
+      expect(result.attributes).toEqual({ keep: "yes" });
+      expect(result.droppedReservedKeys).toHaveLength(7);
+    });
+
+    test("records numbers and booleans as text instead of dropping them", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          shard: 3,
+          ratio: 0.5,
+          negative: -1,
+          zero: 0,
+          primary: true,
+          replica: false,
+        });
+
+      expect(result.attributes).toEqual({
+        shard: "3",
+        ratio: "0.5",
+        negative: "-1",
+        zero: "0",
+        primary: "true",
+        replica: "false",
+      });
+    });
+
+    test("drops values with no usable string form", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          nested: { a: 1 },
+          list: [1, 2],
+          nothing: null,
+          notANumber: Number.NaN,
+          unbounded: Number.POSITIVE_INFINITY,
+          kept: "yes",
+        } as unknown as JSONObject);
+
+      expect(result.attributes).toEqual({ kept: "yes" });
+    });
+
+    test("drops empty and whitespace-only keys, which no filter could ever select", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          "": "a",
+          "   ": "b",
+          ok: "c",
+        });
+
+      expect(result.attributes).toEqual({ ok: "c" });
+    });
+
+    test("trims keys, so a padded spelling cannot slip past the reserved list", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          "  service.name  ": "payments-api",
+          "  region  ": "us-east-1",
+        });
+
+      expect(result.attributes).toEqual({ region: "us-east-1" });
+      expect(result.droppedReservedKeys).toEqual(["service.name"]);
+    });
+
+    test("first key wins when two keys collide after trimming", () => {
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          region: "first",
+          " region": "second",
+        });
+
+      expect(result.attributes).toEqual({ region: "first" });
+    });
+
+    test("caps the attribute count, key length and value length", () => {
+      const attributes: JSONObject = {};
+      for (let i: number = 0; i < MaxCapturedMetricAttributes + 25; i++) {
+        attributes[`key${i}`] = "value";
+      }
+      attributes["x".repeat(MaxCapturedMetricAttributeKeyLength + 50)] = "y";
+
+      const result: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize(attributes);
+
+      expect(Object.keys(result.attributes)).toHaveLength(
+        MaxCapturedMetricAttributes,
+      );
+
+      const longValue: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          long: "z".repeat(MaxCapturedMetricAttributeValueLength + 100),
+        });
+
+      expect((longValue.attributes["long"] as string).length).toBe(
+        MaxCapturedMetricAttributeValueLength,
+      );
+
+      const longKey: SanitizedCapturedMetricAttributes =
+        CapturedMetricAttributeUtil.sanitize({
+          ["k".repeat(MaxCapturedMetricAttributeKeyLength + 100)]: "v",
+        });
+
+      expect(Object.keys(longKey.attributes)[0]!.length).toBe(
+        MaxCapturedMetricAttributeKeyLength,
+      );
+    });
+
+    test("returns an empty set for absent or non-object attributes", () => {
+      expect(
+        CapturedMetricAttributeUtil.sanitize(undefined).attributes,
+      ).toEqual({});
+      expect(CapturedMetricAttributeUtil.sanitize(null).attributes).toEqual({});
+      expect(
+        CapturedMetricAttributeUtil.sanitize(
+          "not an object" as unknown as JSONObject,
+        ).attributes,
+      ).toEqual({});
+    });
+
+    test("does not pollute Object.prototype through a __proto__ key", () => {
+      CapturedMetricAttributeUtil.sanitize({
+        __proto__: "pwned",
+        "__proto__.polluted": "pwned",
+      } as unknown as JSONObject);
+
+      expect(({} as JSONObject)["polluted"]).toBeUndefined();
+    });
+  });
+});