@oneuptime/common 12.0.10 → 12.0.12

package/Tests/Server/Utils/VM/VMRunnerIsolation.test.ts

@@ -0,0 +1,385 @@
+import VMRunner from "../../../../Server/Utils/VM/VMRunner";
+import ReturnResult from "../../../../Types/IsolatedVM/ReturnResult";
+import { JSONObject } from "../../../../Types/JSON";
+import { describe, expect, jest, test } from "@jest/globals";
+import axios from "axios";
+
+jest.setTimeout(60000);
+
+async function runInSandbox(data: {
+  code: string;
+  args?: JSONObject | undefined;
+  timeout?: number | undefined;
+}): Promise<ReturnResult> {
+  return VMRunner.runCodeInSandbox({
+    code: data.code,
+    options: {
+      args: data.args,
+      timeout: data.timeout || 5000,
+    },
+  });
+}
+
+describe("VMRunner isolated-vm boundary", () => {
+  test("does not expose the legacy Node vm runner", () => {
+    const runnerApi: Record<string, unknown> = VMRunner as unknown as Record<
+      string,
+      unknown
+    >;
+
+    expect(runnerApi["runCodeInNodeVM"]).toBeUndefined();
+  });
+
+  test("does not expose Reference methods or temporary host globals", async () => {
+    const result: ReturnResult = await runInSandbox({
+      code: `
+        const privateNames = [
+          '_log',
+          '_captureMetric',
+          '_args',
+          '_axiosRef',
+          '_cryptoRef',
+          '_sleepRef',
+          '__oneuptimeHostLogCallback',
+          '__oneuptimeHostMetricCallback',
+          '__oneuptimeCopiedArgs',
+          '__oneuptimeHostAxiosCallback',
+          '__oneuptimeHostAxiosStartCallback',
+          '__oneuptimeHostAxiosPollCallback',
+          '__oneuptimeHostCryptoCallback',
+          '__oneuptimeHostSleepCallback',
+          '__oneuptimeHostSleepStartCallback',
+          '__oneuptimeHostSleepPollCallback',
+        ];
+        const referenceMethods = [
+          'applySync',
+          'applySyncPromise',
+          'copy',
+          'copySync',
+          'deref',
+          'derefInto',
+          'getSync',
+          'release',
+          'setSync',
+        ];
+        const publicValues = [
+          console,
+          console.log,
+          oneuptime,
+          oneuptime.captureMetric,
+          args,
+          axios,
+          axios.get,
+          crypto,
+          crypto.randomUUID,
+          setTimeout,
+          sleep,
+        ];
+
+        return {
+          privateNamesPresent: privateNames.filter(name => name in globalThis),
+          valuesWithReferenceMethods: publicValues.map((value, index) => ({
+            index,
+            methods: referenceMethods.filter(method => {
+              try { return typeof value[method] !== 'undefined'; }
+              catch (_) { return true; }
+            }),
+          })).filter(entry => entry.methods.length > 0),
+        };
+      `,
+    });
+
+    expect(result.scriptError).toBeUndefined();
+    expect(result.returnValue).toEqual({
+      privateNamesPresent: [],
+      valuesWithReferenceMethods: [],
+    });
+  });
+
+  test("keeps every public function constructor in the isolate realm", async () => {
+    const result: ReturnResult = await runInSandbox({
+      code: `
+        const functions = [
+          console.log,
+          oneuptime.captureMetric,
+          axios,
+          axios.get,
+          crypto.randomUUID,
+          setTimeout,
+          sleep,
+          http.Agent,
+          https.Agent,
+        ];
+
+        return {
+          directFunction: Function('return typeof process')(),
+          constructors: functions.map(fn =>
+            fn.constructor.constructor('return typeof process')()
+          ),
+        };
+      `,
+    });
+
+    expect(result.scriptError).toBeUndefined();
+    expect(result.returnValue).toEqual({
+      directFunction: "undefined",
+      constructors: Array(9).fill("undefined"),
+    });
+  });
+
+  test("keeps promises returned by async shims in the isolate realm", async () => {
+    const result: ReturnResult = await runInSandbox({
+      code: `
+        const sleepPromise = sleep(0);
+        const axiosPromise = axios.get('http://127.0.0.1:8080/');
+        const promiseRealms = [sleepPromise, axiosPromise].map(promise =>
+          promise.constructor.constructor('return typeof process')()
+        );
+
+        await sleepPromise;
+        try { await axiosPromise; } catch (_) {}
+        return promiseRealms;
+      `,
+    });
+
+    expect(result.scriptError).toBeUndefined();
+    expect(result.returnValue).toEqual(["undefined", "undefined"]);
+  });
+
+  test("deep-copies args into the isolate realm", async () => {
+    const args: JSONObject = {
+      nested: {
+        value: "host value",
+      },
+      items: [1, 2, 3],
+    };
+
+    const result: ReturnResult = await runInSandbox({
+      args,
+      code: `
+        args.nested.value = 'isolate value';
+        args.items.push(4);
+
+        return {
+          nestedValue: args.nested.value,
+          itemCount: args.items.length,
+          objectPrototypeIsLocal: Object.getPrototypeOf(args) === Object.prototype,
+          constructorRealm: args.constructor.constructor('return typeof process')(),
+        };
+      `,
+    });
+
+    expect(result.scriptError).toBeUndefined();
+    expect(result.returnValue).toEqual({
+      nestedValue: "isolate value",
+      itemCount: 4,
+      objectPrototypeIsLocal: true,
+      constructorRealm: "undefined",
+    });
+    expect(args).toEqual({
+      nested: {
+        value: "host value",
+      },
+      items: [1, 2, 3],
+    });
+  });
+
+  test("retains logs and metrics when user code throws", async () => {
+    const result: ReturnResult = await runInSandbox({
+      code: `
+        console.log('before throw', { safe: true });
+        oneuptime.captureMetric('sandbox_metric', 42, { region: 'test' });
+        const error = new Error('expected isolate failure');
+        error.untrustedProperty = 'must not cross';
+        throw error;
+      `,
+    });
+
+    expect(result.returnValue).toBeUndefined();
+    expect(result.logMessages).toEqual(['before throw {"safe":true}']);
+    expect(result.capturedMetrics).toEqual([
+      {
+        name: "sandbox_metric",
+        value: 42,
+        attributes: { region: "test" },
+      },
+    ]);
+    expect(result.scriptError).toBeInstanceOf(Error);
+    expect(result.scriptError?.message).toBe("expected isolate failure");
+    expect(
+      (result.scriptError as Error & { untrustedProperty?: string })
+        .untrustedProperty,
+    ).toBeUndefined();
+    expect(result.scriptError?.stack).not.toContain("untrustedProperty");
+  });
+
+  test("retains logs and metrics when user code times out", async () => {
+    const result: ReturnResult = await runInSandbox({
+      timeout: 50,
+      code: `
+        console.log('before timeout');
+        oneuptime.captureMetric('timeout_metric', 7);
+        while (true) {}
+      `,
+    });
+
+    expect(result.returnValue).toBeUndefined();
+    expect(result.logMessages).toEqual(["before timeout"]);
+    expect(result.capturedMetrics).toEqual([
+      {
+        name: "timeout_metric",
+        value: 7,
+      },
+    ]);
+    expect(result.scriptError?.message).toMatch(/timed out/i);
+  });
+
+  test("bounds log count and aggregate UTF-8 bytes", async () => {
+    const countResult: ReturnResult = await runInSandbox({
+      code: `
+        for (let index = 0; index < 1100; index++) {
+          console.log('entry-' + index);
+        }
+        return 'done';
+      `,
+    });
+
+    expect(countResult.scriptError).toBeUndefined();
+    expect(countResult.returnValue).toBe("done");
+    expect(countResult.logMessages).toHaveLength(1000);
+
+    const byteResult: ReturnResult = await runInSandbox({
+      code: `
+        const message = '\u00e9'.repeat(70000);
+        for (let index = 0; index < 10; index++) {
+          console.log(message);
+        }
+        return 'done';
+      `,
+    });
+    const totalBytes: number = byteResult.logMessages.reduce(
+      (bytes: number, message: string): number => {
+        return bytes + Buffer.byteLength(message, "utf8");
+      },
+      0,
+    );
+
+    expect(byteResult.scriptError).toBeUndefined();
+    expect(totalBytes).toBeLessThanOrEqual(1_000_000);
+    expect(byteResult.logMessages).toHaveLength(7);
+  });
+
+  test("preserves timer behavior and clears pending host timers", async () => {
+    jest.spyOn(global, "clearTimeout");
+
+    try {
+      const result: ReturnResult = await runInSandbox({
+        timeout: 250,
+        code: `
+          let cancelledTimerFired = false;
+          const cancelledTimer = setTimeout(() => {
+            cancelledTimerFired = true;
+          }, 5);
+          clearTimeout(cancelledTimer);
+
+          const startedAt = Date.now();
+          await new Promise(resolve => setTimeout(resolve, 10));
+          const elapsed = Date.now() - startedAt;
+
+          setTimeout(() => console.log('late timer'), 60000);
+          await sleep(5);
+
+          return {
+            cancelledTimerFired,
+            elapsed,
+          };
+        `,
+      });
+
+      expect(result.scriptError).toBeUndefined();
+      expect(result.returnValue.cancelledTimerFired).toBe(false);
+      expect(result.returnValue.elapsed).toBeGreaterThanOrEqual(5);
+      expect(result.logMessages).not.toContain("late timer");
+      expect(
+        jest.mocked(global.clearTimeout).mock.calls.length,
+      ).toBeGreaterThanOrEqual(2);
+    } finally {
+      jest.restoreAllMocks();
+    }
+  });
+
+  test("copies a fulfilled axios response back into the isolate", async () => {
+    jest.spyOn(axios, "get").mockResolvedValue({
+      status: 200,
+      headers: { "x-test": "copied" },
+      data: { ok: true },
+    } as never);
+
+    try {
+      const result: ReturnResult = await runInSandbox({
+        code: `
+          const response = await axios.get('https://8.8.8.8/health');
+          return {
+            status: response.status,
+            header: response.headers['x-test'],
+            data: response.data,
+            promiseRealm: axios.get('https://8.8.8.8/second')
+              .constructor.constructor('return typeof process')(),
+          };
+        `,
+      });
+
+      expect(result.scriptError).toBeUndefined();
+      expect(result.returnValue).toEqual({
+        status: 200,
+        header: "copied",
+        data: { ok: true },
+        promiseRealm: "undefined",
+      });
+      expect(axios.get).toHaveBeenCalledWith(
+        "https://8.8.8.8/health",
+        expect.objectContaining({
+          maxRedirects: 0,
+          signal: expect.any(AbortSignal),
+        }),
+      );
+    } finally {
+      jest.restoreAllMocks();
+    }
+  });
+
+  test("keeps the documented crypto and Agent shims compatible", async () => {
+    const result: ReturnResult = await runInSandbox({
+      code: `
+        const httpAgent = new http.Agent({ keepAlive: true });
+        const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+
+        return {
+          hash: crypto.createHash('sha256').update('oneuptime').digest('hex'),
+          uuidLooksValid: /^[0-9a-f-]{36}$/.test(crypto.randomUUID()),
+          randomIntInRange: (() => {
+            const value = crypto.randomInt(2, 5);
+            return value >= 2 && value < 5;
+          })(),
+          httpAgent,
+          httpsAgent,
+        };
+      `,
+    });
+
+    expect(result.scriptError).toBeUndefined();
+    expect(result.returnValue).toEqual({
+      hash: "35a18a92a1ae8387b173763364c1497950fa0bfe2589e545c0bf1f4d0f01f94e",
+      uuidLooksValid: true,
+      randomIntInRange: true,
+      httpAgent: {
+        __agentType: "__http_agent__",
+        options: { keepAlive: true },
+      },
+      httpsAgent: {
+        __agentType: "__https_agent__",
+        options: { rejectUnauthorized: false },
+      },
+    });
+  });
+});

package/Tests/Server/Utils/VM/VMRunnerSsrf.test.ts

@@ -33,6 +33,9 @@ async function runInSandbox(code: string): Promise<ReturnResult> {
 async function errorFromSandbox(code: string): Promise<string> {
   try {
     const result: ReturnResult = await runInSandbox(code);
+    if (result.scriptError) {
+      return result.scriptError.message;
+    }
     return JSON.stringify(result.returnValue ?? result.logMessages ?? "");
   } catch (err) {
     return (err as Error).message || String(err);

package/Tests/Types/Billing/PayAsYouGoPricing.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH,
+  PRICING_PAGE_URL,
+  SESSION_REPLAY_PRICE_IN_USD_PER_GB,
+  TELEMETRY_PRICE_IN_USD_PER_GB,
+  TELEMETRY_PRICE_RETENTION_IN_DAYS,
+  formatPriceInUSD,
+} from "../../../Types/Billing/PayAsYouGoPricing";
+
+/*
+ * These constants are quoted to users, verbatim, on the telemetry ingestion
+ * key and create monitor pages. They are pinned here because changing one
+ * silently changes what the product promises a customer - a change to any of
+ * them has to be deliberate, and has to be made on the pricing page too.
+ */
+
+describe("PayAsYouGoPricing", () => {
+  describe("rates", () => {
+    it("charges $0.10 per GB of telemetry, quoted for 15 day retention", () => {
+      expect(TELEMETRY_PRICE_IN_USD_PER_GB).toBe(0.1);
+      expect(TELEMETRY_PRICE_RETENTION_IN_DAYS).toBe(15);
+    });
+
+    it("charges $2 per GB for session replay, on the same 15 day window", () => {
+      expect(SESSION_REPLAY_PRICE_IN_USD_PER_GB).toBe(2);
+    });
+
+    it("charges $1 per active monitor per month", () => {
+      expect(ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH).toBe(1);
+    });
+
+    it("points at the public pricing page", () => {
+      expect(PRICING_PAGE_URL).toBe("https://oneuptime.com/pricing");
+    });
+  });
+
+  describe("formatPriceInUSD", () => {
+    it("writes a whole number of dollars without cents, like the pricing page", () => {
+      expect(formatPriceInUSD(1)).toBe("$1");
+      expect(formatPriceInUSD(22)).toBe("$22");
+      expect(formatPriceInUSD(0)).toBe("$0");
+    });
+
+    it("writes a fractional amount with two decimal places", () => {
+      expect(formatPriceInUSD(0.1)).toBe("$0.10");
+      expect(formatPriceInUSD(1.5)).toBe("$1.50");
+      expect(formatPriceInUSD(2.05)).toBe("$2.05");
+    });
+
+    it("rounds to cents rather than spilling extra digits into the copy", () => {
+      expect(formatPriceInUSD(0.125)).toBe("$0.13");
+      expect(formatPriceInUSD(0.006)).toBe("$0.01");
+    });
+
+    it("renders the advertised rates exactly as the pricing page writes them", () => {
+      expect(formatPriceInUSD(TELEMETRY_PRICE_IN_USD_PER_GB)).toBe("$0.10");
+      expect(formatPriceInUSD(SESSION_REPLAY_PRICE_IN_USD_PER_GB)).toBe("$2");
+      expect(formatPriceInUSD(ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH)).toBe(
+        "$1",
+      );
+    });
+  });
+});

package/Tests/Types/CustomField/CustomFieldTypeCorrespondence.test.ts

@@ -0,0 +1,107 @@
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * CustomFieldsDetail does not translate a definition's `customFieldType` into a
+ * render type - it hands the raw string to a Detail field and to a form field
+ * as their `fieldType`, through an `as any` that erases the enum on the way.
+ * Nothing in the compiler is watching that seam, so a member added here without
+ * a same-VALUE member in FieldType and FormFieldSchemaType type-checks, builds,
+ * ships, and only then shows itself: the Detail column falls off the end of the
+ * render switch and paints an empty cell, and the form falls off the end of the
+ * input switch and paints a control the user cannot type into. The field looks
+ * present and is silently unusable, which is the worst shape a regression can
+ * take because nothing throws and nothing logs.
+ *
+ * These are value-set comparisons rather than key comparisons on purpose. The
+ * three enums are free to spell a member however reads best on their own side -
+ * `Boolean` reaches the form as `FormFieldSchemaType.Toggle`, which is written
+ * `Toggle = "Boolean"` for exactly this reason - and only the value crosses the
+ * seam. A key-based check would both miss real breakage and reject that legal
+ * spelling.
+ */
+
+const customFieldTypeEntries: Array<[string, string]> = Object.entries(
+  CustomFieldType,
+) as Array<[string, string]>;
+
+const fieldTypeValues: Set<string> = new Set<string>(
+  Object.values(FieldType) as Array<string>,
+);
+
+const formFieldSchemaTypeValues: Set<string> = new Set<string>(
+  Object.values(FormFieldSchemaType) as Array<string>,
+);
+
+describe("CustomFieldType corresponds to FieldType", () => {
+  test.each(customFieldTypeEntries)(
+    "CustomFieldType.%s is a FieldType value",
+    (_key: string, value: string) => {
+      expect(fieldTypeValues.has(value)).toBe(true);
+    },
+  );
+});
+
+describe("CustomFieldType corresponds to FormFieldSchemaType", () => {
+  test.each(customFieldTypeEntries)(
+    "CustomFieldType.%s is a FormFieldSchemaType value",
+    (_key: string, value: string) => {
+      expect(formFieldSchemaTypeValues.has(value)).toBe(true);
+    },
+  );
+});
+
+describe("CustomFieldType member set", () => {
+  test("has at least one member so the correspondence loops cannot pass vacuously", () => {
+    /*
+     * The two blocks above are generated from this enum. If it were ever
+     * emptied - a bad merge, a barrel file re-export that resolves to {} - the
+     * per-member assertions would simply stop existing and the suite would go
+     * green while guarding nothing.
+     */
+    expect(customFieldTypeEntries.length).toBeGreaterThan(0);
+  });
+
+  test("has no duplicate values", () => {
+    /*
+     * Two keys sharing a value collapse at runtime: the second one wins every
+     * lookup, and a definition saved under the first key renders as the second
+     * one's type. It also makes the loops above lie, because a duplicate is
+     * checked twice and the shadowed member is never exercised on its own.
+     */
+    const values: Array<string> = customFieldTypeEntries.map(
+      ([, value]: [string, string]) => {
+        return value;
+      },
+    );
+
+    expect(new Set<string>(values).size).toBe(values.length);
+  });
+
+  test("includes Date and DateTime", () => {
+    /*
+     * The date members are what the jsonb range filters and the ISO-8601
+     * storage format exist for. Losing them is a silent feature removal - old
+     * definitions keep their stored `customFieldType` string in the database
+     * and would then fall through every switch that reads this enum.
+     */
+    expect(CustomFieldType.Date).toEqual("Date");
+    expect(CustomFieldType.DateTime).toEqual("DateTime");
+  });
+});
+
+describe("CustomFieldType correspondence is by value, not by key", () => {
+  test("Boolean reaches the form as Toggle, which is only visible by value", () => {
+    /*
+     * This is the case that proves the checks above have to compare values.
+     * FormFieldSchemaType has no member named `Boolean`; it names the same
+     * value `Toggle`. A correspondence test written against key names would
+     * fail here on code that works perfectly, and would then be "fixed" by
+     * relaxing it into something that no longer catches a missing member.
+     */
+    expect(Object.keys(FormFieldSchemaType)).not.toContain("Boolean");
+    expect(FormFieldSchemaType.Toggle).toEqual(CustomFieldType.Boolean);
+  });
+});

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

@@ -253,6 +253,68 @@ describe("MonitorTypeHelper", () => {
     });
   });
 
+  /*
+   * The dashboard tells Free plan users which monitors cost money before they
+   * create one, and gates the create button on acknowledging it. That warning
+   * is only honest while this predicate agrees with what the server actually
+   * meters - ActiveMonitoringMeteredPlan counts every monitor whose type is
+   * not Manual.
+   */
+  describe("isBilledAsActiveMonitor", () => {
+    test("Manual monitors are free", () => {
+      expect(
+        MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Manual),
+      ).toBe(false);
+    });
+
+    test("every other monitor type is billed", () => {
+      const billed: Array<MonitorType> = Object.values(MonitorType).filter(
+        (monitorType: MonitorType) => {
+          return monitorType !== MonitorType.Manual;
+        },
+      );
+
+      expect(billed.length).toBeGreaterThan(0);
+
+      for (const monitorType of billed) {
+        expect(MonitorTypeHelper.isBilledAsActiveMonitor(monitorType)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("telemetry monitors are billed as active monitors too, on top of their ingest", () => {
+      expect(MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Logs)).toBe(
+        true,
+      );
+      expect(
+        MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Metrics),
+      ).toBe(true);
+      expect(
+        MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Traces),
+      ).toBe(true);
+    });
+
+    test("agrees exactly with getActiveMonitorTypes", () => {
+      const active: Array<MonitorType> =
+        MonitorTypeHelper.getActiveMonitorTypes();
+
+      for (const monitorType of Object.values(MonitorType)) {
+        expect(MonitorTypeHelper.isBilledAsActiveMonitor(monitorType)).toBe(
+          active.includes(monitorType),
+        );
+      }
+    });
+
+    test("is the exact inverse of isManualMonitor", () => {
+      for (const monitorType of Object.values(MonitorType)) {
+        expect(MonitorTypeHelper.isBilledAsActiveMonitor(monitorType)).toBe(
+          !MonitorTypeHelper.isManualMonitor(monitorType),
+        );
+      }
+    });
+  });
+
   describe("doesMonitorTypeHaveGraphs", () => {
     test("returns true for graphable types and false otherwise", () => {
       expect(