@oneuptime/common 10.0.65 → 10.0.66

package/Tests/Utils/Metrics/MetricResultUnitConverter.test.ts

@@ -0,0 +1,231 @@
+import MetricResultUnitConverter from "../../../Utils/Metrics/MetricResultUnitConverter";
+import MetricFormulaEvaluator from "../../../Utils/Metrics/MetricFormulaEvaluator";
+import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+
+type BuildQueryConfigFunction = (input: {
+  variable: string;
+  metricName: string;
+  legendUnit?: string;
+}) => MetricQueryConfigData;
+
+const buildQueryConfig: BuildQueryConfigFunction = (input: {
+  variable: string;
+  metricName: string;
+  legendUnit?: string;
+}): MetricQueryConfigData => {
+  return {
+    metricAliasData: {
+      metricVariable: input.variable,
+      title: "",
+      description: "",
+      legend: "",
+      legendUnit: input.legendUnit ?? "",
+    },
+    metricQueryData: {
+      filterData: {
+        metricName: input.metricName,
+        aggegationType: MetricsAggregationType.Avg,
+      },
+    },
+  };
+};
+
+type BuildResultFunction = (values: Array<number>) => AggregatedResult;
+
+const buildResult: BuildResultFunction = (
+  values: Array<number>,
+): AggregatedResult => {
+  return {
+    data: values.map((v: number, index: number) => {
+      return {
+        timestamp: new Date(`2026-04-20T00:0${index}:00.000Z`),
+        value: v,
+      };
+    }),
+  };
+};
+
+describe("MetricResultUnitConverter", () => {
+  test("converts bytes series to GB when user picked GB", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({
+        variable: "a",
+        metricName: "memory.usage",
+        legendUnit: "GB",
+      }),
+    ];
+    const results: Array<AggregatedResult> = [
+      // 1 GB, 2 GB, 0.5 GB (expressed in bytes — OpenTelemetry's native)
+      buildResult([1_000_000_000, 2_000_000_000, 500_000_000]),
+    ];
+    const nativeUnits: Map<string, string> = new Map([
+      ["memory.usage", "bytes"],
+    ]);
+
+    const out: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    expect(
+      out[0]!.data.map((d: { value: number }) => {
+        return d.value;
+      }),
+    ).toEqual([1, 2, 0.5]);
+  });
+
+  test("passes values through when legendUnit is empty", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({ variable: "a", metricName: "memory.usage" }),
+    ];
+    const results: Array<AggregatedResult> = [buildResult([1_000_000_000])];
+    const nativeUnits: Map<string, string> = new Map([
+      ["memory.usage", "bytes"],
+    ]);
+
+    const out: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    expect(out[0]!.data[0]!.value).toBe(1_000_000_000);
+  });
+
+  test("passes values through when native unit is unknown", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({
+        variable: "a",
+        metricName: "custom.metric",
+        legendUnit: "GB",
+      }),
+    ];
+    const results: Array<AggregatedResult> = [buildResult([1_000_000_000])];
+    // No entry for custom.metric
+    const nativeUnits: Map<string, string> = new Map();
+
+    const out: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    expect(out[0]!.data[0]!.value).toBe(1_000_000_000);
+  });
+
+  test("no-op when native unit already matches legendUnit", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({
+        variable: "a",
+        metricName: "latency",
+        legendUnit: "ms",
+      }),
+    ];
+    const results: Array<AggregatedResult> = [buildResult([250, 500])];
+    const nativeUnits: Map<string, string> = new Map([["latency", "ms"]]);
+
+    const out: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    // Returns the same AggregatedResult reference — no allocation needed
+    expect(out[0]).toBe(results[0]);
+  });
+
+  test("converts ms → sec (time family)", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({
+        variable: "a",
+        metricName: "request.time",
+        legendUnit: "sec",
+      }),
+    ];
+    const results: Array<AggregatedResult> = [buildResult([1000, 2500, 10000])];
+    const nativeUnits: Map<string, string> = new Map([["request.time", "ms"]]);
+
+    const out: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    expect(
+      out[0]!.data.map((d: { value: number }) => {
+        return d.value;
+      }),
+    ).toEqual([1, 2.5, 10]);
+  });
+
+  test("formula respects the query's display unit (3600s metric → 1h → 2*a = 2)", () => {
+    /*
+     * Mirrors the scenario in the user-facing Metric Explorer: a metric
+     * stored in seconds, user picks "hours" from the unit dropdown, and
+     * writes a formula of `2 * $a`. Because MetricResultUnitConverter
+     * converts 3600s → 1h before the formula runs, `2 * $a` must
+     * evaluate to 2 (not 7200). This test protects that contract from
+     * future regressions across either layer.
+     */
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({
+        variable: "a",
+        metricName: "response.time",
+        legendUnit: "hours",
+      }),
+    ];
+    const rawResults: Array<AggregatedResult> = [buildResult([3600])];
+    const nativeUnits: Map<string, string> = new Map([
+      ["response.time", "seconds"],
+    ]);
+
+    const converted: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results: rawResults,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    expect(converted[0]!.data[0]!.value).toBe(1);
+
+    const formulaResult: AggregatedResult =
+      MetricFormulaEvaluator.evaluateFormula({
+        formula: "2 * $a",
+        queryConfigs,
+        formulaConfigs: [],
+        results: converted,
+      });
+
+    expect(formulaResult.data[0]!.value).toBe(2);
+  });
+
+  test("passes values through across incompatible unit families", () => {
+    // User legendUnit "GB", native "ms" — different families, can't convert
+    const queryConfigs: Array<MetricQueryConfigData> = [
+      buildQueryConfig({
+        variable: "a",
+        metricName: "nonsense",
+        legendUnit: "GB",
+      }),
+    ];
+    const results: Array<AggregatedResult> = [buildResult([123])];
+    const nativeUnits: Map<string, string> = new Map([["nonsense", "ms"]]);
+
+    const out: Array<AggregatedResult> =
+      MetricResultUnitConverter.convertQueryResultsToDisplayUnit({
+        queryConfigs,
+        results,
+        nativeUnitByMetricName: nativeUnits,
+      });
+
+    expect(out[0]!.data[0]!.value).toBe(123);
+  });
+});

package/Tests/Utils/RecordingRuleExpression.test.ts

@@ -0,0 +1,177 @@
+import {
+  evaluate,
+  parse,
+  validate,
+  type Node,
+  type ParseError,
+  type ParseResult,
+} from "../../Utils/Metrics/RecordingRuleExpression";
+
+function parseOk(input: string): ParseResult {
+  const r: ParseResult | ParseError = parse(input);
+  if (!r.ok) {
+    throw new Error(
+      `Expected parse to succeed for "${input}" but got: ${r.error}`,
+    );
+  }
+  return r;
+}
+
+function evalOk(input: string, bindings: Record<string, number>): number {
+  const r: ParseResult = parseOk(input);
+  const v: number | null = evaluate(r.ast, bindings);
+  if (v === null) {
+    throw new Error(`Expected "${input}" to evaluate to a number, got null`);
+  }
+  return v;
+}
+
+describe("RecordingRuleExpression", () => {
+  describe("parse + evaluate", () => {
+    test("numeric literal", () => {
+      expect(evalOk("42", {})).toBe(42);
+      expect(evalOk("3.14", {})).toBeCloseTo(3.14);
+    });
+
+    test("identifier binding", () => {
+      expect(evalOk("A", { A: 7 })).toBe(7);
+    });
+
+    test("basic arithmetic", () => {
+      expect(evalOk("A + B", { A: 3, B: 4 })).toBe(7);
+      expect(evalOk("A - B", { A: 10, B: 3 })).toBe(7);
+      expect(evalOk("A * B", { A: 6, B: 7 })).toBe(42);
+      expect(evalOk("A / B", { A: 10, B: 2 })).toBe(5);
+    });
+
+    test("operator precedence", () => {
+      // * binds tighter than +
+      expect(evalOk("A + B * C", { A: 1, B: 2, C: 3 })).toBe(7);
+      // parens override
+      expect(evalOk("(A + B) * C", { A: 1, B: 2, C: 3 })).toBe(9);
+    });
+
+    test("unary minus", () => {
+      expect(evalOk("-A", { A: 5 })).toBe(-5);
+      expect(evalOk("-(A + B)", { A: 1, B: 2 })).toBe(-3);
+      expect(evalOk("A + -B", { A: 10, B: 3 })).toBe(7);
+    });
+
+    test("real-world error rate expression", () => {
+      // http.error_rate = errors / requests * 100
+      expect(evalOk("A / B * 100", { A: 3, B: 10 })).toBe(30);
+    });
+
+    test("whitespace tolerant", () => {
+      expect(evalOk("   A  +   B  ", { A: 1, B: 2 })).toBe(3);
+    });
+
+    test("division by zero returns null", () => {
+      const r: ParseResult = parseOk("A / B");
+      expect(evaluate(r.ast, { A: 5, B: 0 })).toBeNull();
+    });
+
+    test("missing binding returns null", () => {
+      const r: ParseResult = parseOk("A + B");
+      expect(evaluate(r.ast, { A: 1 })).toBeNull();
+    });
+
+    test("non-finite input returns null", () => {
+      const r: ParseResult = parseOk("A + B");
+      expect(evaluate(r.ast, { A: Number.NaN, B: 1 })).toBeNull();
+      expect(evaluate(r.ast, { A: Number.POSITIVE_INFINITY, B: 1 })).toBeNull();
+    });
+
+    test("binary overflow guarded", () => {
+      // Number.MAX_VALUE * 2 overflows to Infinity → null.
+      const r: ParseResult = parseOk("A * B");
+      expect(evaluate(r.ast, { A: Number.MAX_VALUE, B: 2 })).toBeNull();
+    });
+  });
+
+  describe("parse errors", () => {
+    test("unexpected character", () => {
+      const r: ParseResult | ParseError = parse("A @ B");
+      expect(r.ok).toBe(false);
+    });
+
+    test("trailing token", () => {
+      const r: ParseResult | ParseError = parse("A B");
+      expect(r.ok).toBe(false);
+    });
+
+    test("missing closing paren", () => {
+      const r: ParseResult | ParseError = parse("(A + B");
+      expect(r.ok).toBe(false);
+    });
+
+    test("empty expression", () => {
+      const r: ParseResult | ParseError = parse("   ");
+      expect(r.ok).toBe(false);
+    });
+
+    test("operator without operand", () => {
+      const r: ParseResult | ParseError = parse("A +");
+      expect(r.ok).toBe(false);
+    });
+  });
+
+  describe("identifier collection", () => {
+    test("lists unique identifiers", () => {
+      const r: ParseResult = parseOk("A + B + A * C");
+      const sorted: Array<string> = [...r.identifiers].sort();
+      expect(sorted).toEqual(["A", "B", "C"]);
+    });
+  });
+
+  describe("validate", () => {
+    test("allows known identifiers", () => {
+      expect(validate("A + B", ["A", "B"]).ok).toBe(true);
+    });
+
+    test("rejects unknown identifiers", () => {
+      const r: { ok: boolean; unknownIdentifiers?: Array<string> } = validate(
+        "A + X",
+        ["A", "B"],
+      );
+      expect(r.ok).toBe(false);
+      expect(r.unknownIdentifiers).toEqual(["X"]);
+    });
+
+    test("surfaces parse errors", () => {
+      const r: { ok: boolean; error?: string } = validate("A +", ["A"]);
+      expect(r.ok).toBe(false);
+      expect(r.error).toBeDefined();
+    });
+  });
+
+  describe("nesting limit", () => {
+    test("rejects deeply nested expression", () => {
+      // Build 100 nested parens: ((((...A...))))
+      let input: string = "A";
+      for (let i: number = 0; i < 100; i++) {
+        input = `(${input})`;
+      }
+      const r: ParseResult | ParseError = parse(input);
+      expect(r.ok).toBe(false);
+    });
+  });
+
+  describe("AST shape", () => {
+    test("respects precedence in AST", () => {
+      const r: ParseResult = parseOk("A + B * C");
+      // Root is +; right side is * node.
+      const ast: Node = r.ast;
+      expect(ast.type).toBe("binary");
+      if (ast.type !== "binary") {
+        return;
+      }
+      expect(ast.op).toBe("+");
+      expect(ast.right.type).toBe("binary");
+      if (ast.right.type !== "binary") {
+        return;
+      }
+      expect(ast.right.op).toBe("*");
+    });
+  });
+});