@oneuptime/common 10.0.65 → 10.0.66

package/build/dist/Utils/MetricUnitUtil.js

@@ -0,0 +1,232 @@
+/*
+ * Unit conversion utilities for metric alert thresholds. Separate from
+ * ValueFormatter (which focuses on auto-scaled display formatting) because
+ * thresholds need deterministic, user-selected units — not whatever unit
+ * happens to read best for a given magnitude.
+ */
+/*
+ * Within a family, `toCanonical` is the multiplier that converts a value
+ * expressed in this unit into the family's canonical base (bytes for data,
+ * seconds for time, % for percent).
+ */
+const byteUnits = [
+    {
+        value: "B",
+        label: "Bytes (B)",
+        aliases: ["b", "byte", "bytes", "by"],
+        toCanonical: 1,
+    },
+    {
+        value: "KB",
+        label: "Kilobytes (KB)",
+        aliases: ["kb", "kilobyte", "kilobytes", "kby"],
+        toCanonical: 1e3,
+    },
+    {
+        value: "MB",
+        label: "Megabytes (MB)",
+        aliases: ["mb", "megabyte", "megabytes", "mby"],
+        toCanonical: 1e6,
+    },
+    {
+        value: "GB",
+        label: "Gigabytes (GB)",
+        aliases: ["gb", "gigabyte", "gigabytes", "gby"],
+        toCanonical: 1e9,
+    },
+    {
+        value: "TB",
+        label: "Terabytes (TB)",
+        aliases: ["tb", "terabyte", "terabytes", "tby"],
+        toCanonical: 1e12,
+    },
+    {
+        value: "PB",
+        label: "Petabytes (PB)",
+        aliases: ["pb", "petabyte", "petabytes", "pby"],
+        toCanonical: 1e15,
+    },
+];
+const timeUnits = [
+    {
+        value: "ns",
+        label: "Nanoseconds (ns)",
+        aliases: ["ns", "nanosecond", "nanoseconds"],
+        toCanonical: 1e-9,
+    },
+    {
+        value: "µs",
+        label: "Microseconds (µs)",
+        aliases: ["µs", "us", "microsecond", "microseconds"],
+        toCanonical: 1e-6,
+    },
+    {
+        value: "ms",
+        label: "Milliseconds (ms)",
+        aliases: ["ms", "millisecond", "milliseconds"],
+        toCanonical: 1e-3,
+    },
+    {
+        value: "sec",
+        label: "Seconds (sec)",
+        aliases: ["s", "sec", "second", "seconds"],
+        toCanonical: 1,
+    },
+    {
+        value: "min",
+        label: "Minutes (min)",
+        aliases: ["min", "minute", "minutes"],
+        toCanonical: 60,
+    },
+    {
+        value: "hours",
+        label: "Hours",
+        aliases: ["h", "hr", "hour", "hours"],
+        toCanonical: 3600,
+    },
+    {
+        value: "days",
+        label: "Days",
+        aliases: ["d", "day", "days"],
+        toCanonical: 86400,
+    },
+];
+const percentUnits = [
+    {
+        value: "%",
+        label: "Percent (%)",
+        aliases: ["%", "percent"],
+        toCanonical: 1,
+    },
+];
+const bitUnits = [
+    {
+        value: "bit",
+        label: "Bits (bit)",
+        aliases: ["bit", "bits"],
+        toCanonical: 1,
+    },
+    {
+        value: "kbit",
+        label: "Kilobits (kbit)",
+        aliases: ["kbit", "kilobit", "kilobits"],
+        toCanonical: 1e3,
+    },
+    {
+        value: "mbit",
+        label: "Megabits (mbit)",
+        aliases: ["mbit", "megabit", "megabits"],
+        toCanonical: 1e6,
+    },
+    {
+        value: "gbit",
+        label: "Gigabits (gbit)",
+        aliases: ["gbit", "gigabit", "gigabits"],
+        toCanonical: 1e9,
+    },
+];
+const allFamilies = [
+    byteUnits,
+    timeUnits,
+    percentUnits,
+    bitUnits,
+];
+function normalize(unit) {
+    return unit.trim().toLowerCase();
+}
+function findDefinitionInFamily(unit, family) {
+    const normalized = normalize(unit);
+    return (family.find((u) => {
+        return u.aliases.includes(normalized);
+    }) || null);
+}
+function findFamily(unit) {
+    if (!unit || !unit.trim()) {
+        return null;
+    }
+    for (const family of allFamilies) {
+        if (findDefinitionInFamily(unit, family)) {
+            return family;
+        }
+    }
+    return null;
+}
+export default class MetricUnitUtil {
+    /*
+     * Returns the dropdown options the UI should show next to the threshold
+     * input, given the metric's native unit. If the unit isn't in any known
+     * family, returns a single option matching the raw unit so users still
+     * see what they're working with.
+     */
+    static getCompatibleUnits(metricUnit) {
+        if (!metricUnit || !metricUnit.trim()) {
+            return [];
+        }
+        const family = findFamily(metricUnit);
+        if (!family) {
+            return [{ value: metricUnit, label: metricUnit }];
+        }
+        return family.map((u) => {
+            return { value: u.value, label: u.label };
+        });
+    }
+    /*
+     * Returns the canonical unit value for the metric's native unit, which
+     * is what the threshold dropdown should default to when nothing is
+     * selected yet. Returns the input unit unchanged if the family is
+     * unknown.
+     */
+    static getCanonicalUnitValue(metricUnit) {
+        if (!metricUnit || !metricUnit.trim()) {
+            return undefined;
+        }
+        const family = findFamily(metricUnit);
+        if (!family) {
+            return metricUnit;
+        }
+        const def = findDefinitionInFamily(metricUnit, family);
+        return (def === null || def === void 0 ? void 0 : def.value) || metricUnit;
+    }
+    /*
+     * Converts a threshold value from the user-selected unit into the
+     * metric's native unit so comparisons can happen against raw samples.
+     * Returns the unchanged value when either unit is unknown or they
+     * belong to different families — the evaluator shouldn't silently
+     * produce nonsense numbers.
+     */
+    static convertToMetricUnit(input) {
+        const { value, fromUnit, metricUnit } = input;
+        if (!fromUnit || !metricUnit) {
+            return value;
+        }
+        if (normalize(fromUnit) === normalize(metricUnit)) {
+            return value;
+        }
+        const family = findFamily(metricUnit);
+        if (!family) {
+            return value;
+        }
+        const fromDef = findDefinitionInFamily(fromUnit, family);
+        const metricDef = findDefinitionInFamily(metricUnit, family);
+        if (!fromDef || !metricDef) {
+            return value;
+        }
+        /*
+         * value_in_canonical = value * fromDef.toCanonical
+         * value_in_metric    = value_in_canonical / metricDef.toCanonical
+         */
+        return (value * fromDef.toCanonical) / metricDef.toCanonical;
+    }
+    /*
+     * Convenience: does the metric unit belong to a family we can offer
+     * conversions for? When false, the UI should still render a dropdown,
+     * but with just the raw unit.
+     */
+    static hasCompatibleUnitFamily(metricUnit) {
+        if (!metricUnit || !metricUnit.trim()) {
+            return false;
+        }
+        return findFamily(metricUnit) !== null;
+    }
+}
+//# sourceMappingURL=MetricUnitUtil.js.map

package/build/dist/Utils/MetricUnitUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricUnitUtil.js","sourceRoot":"","sources":["../../../Utils/MetricUnitUtil.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH;;;;GAIG;AACH,MAAM,SAAS,GAA0B;IACvC;QACE,KAAK,EAAE,GAAG;QACV,KAAK,EAAE,WAAW;QAClB,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;QACrC,WAAW,EAAE,CAAC;KACf;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,gBAAgB;QACvB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC;QAC/C,WAAW,EAAE,GAAG;KACjB;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,gBAAgB;QACvB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC;QAC/C,WAAW,EAAE,GAAG;KACjB;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,gBAAgB;QACvB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC;QAC/C,WAAW,EAAE,GAAG;KACjB;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,gBAAgB;QACvB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC;QAC/C,WAAW,EAAE,IAAI;KAClB;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,gBAAgB;QACvB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC;QAC/C,WAAW,EAAE,IAAI;KAClB;CACF,CAAC;AAEF,MAAM,SAAS,GAA0B;IACvC;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,kBAAkB;QACzB,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,aAAa,CAAC;QAC5C,WAAW,EAAE,IAAI;KAClB;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,mBAAmB;QAC1B,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,CAAC;QACpD,WAAW,EAAE,IAAI;KAClB;IACD;QACE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,mBAAmB;QAC1B,OAAO,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,cAAc,CAAC;QAC9C,WAAW,EAAE,IAAI;KAClB;IACD;QACE,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,eAAe;QACtB,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC1C,WAAW,EAAE,CAAC;KACf;IACD;QACE,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,eAAe;QACtB,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC;QACrC,WAAW,EAAE,EAAE;KAChB;IACD;QACE,KAAK,EAAE,OAAO;QACd,KAAK,EAAE,OAAO;QACd,OAAO,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;QACrC,WAAW,EAAE,IAAI;KAClB;IACD;QACE,KAAK,EAAE,MAAM;QACb,KAAK,EAAE,MAAM;QACb,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC;QAC7B,WAAW,EAAE,KAAK;KACnB;CACF,CAAC;AAEF,MAAM,YAAY,GAA0B;IAC1C;QACE,KAAK,EAAE,GAAG;QACV,KAAK,EAAE,aAAa;QACpB,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,CAAC;QACzB,WAAW,EAAE,CAAC;KACf;CACF,CAAC;AAEF,MAAM,QAAQ,GAA0B;IACtC;QACE,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;QACxB,WAAW,EAAE,CAAC;KACf;IACD;QACE,KAAK,EAAE,MAAM;QACb,KAAK,EAAE,iBAAiB;QACxB,OAAO,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC;QACxC,WAAW,EAAE,GAAG;KACjB;IACD;QACE,KAAK,EAAE,MAAM;QACb,KAAK,EAAE,iBAAiB;QACxB,OAAO,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC;QACxC,WAAW,EAAE,GAAG;KACjB;IACD;QACE,KAAK,EAAE,MAAM;QACb,KAAK,EAAE,iBAAiB;QACxB,OAAO,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC;QACxC,WAAW,EAAE,GAAG;KACjB;CACF,CAAC;AAEF,MAAM,WAAW,GAAiC;IAChD,SAAS;IACT,SAAS;IACT,YAAY;IACZ,QAAQ;CACT,CAAC;AAEF,SAAS,SAAS,CAAC,IAAY;IAC7B,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AACnC,CAAC;AAED,SAAS,sBAAsB,CAC7B,IAAY,EACZ,MAA6B;IAE7B,MAAM,UAAU,GAAW,SAAS,CAAC,IAAI,CAAC,CAAC;IAC3C,OAAO,CACL,MAAM,CAAC,IAAI,CAAC,CAAC,CAAiB,EAAE,EAAE;QAChC,OAAO,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC,CAAC,IAAI,IAAI,CACX,CAAC;AACJ,CAAC;AAED,SAAS,UAAU,CAAC,IAAY;IAC9B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,WAAW,EAAE,CAAC;QACjC,IAAI,sBAAsB,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC;YACzC,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC;;;;;OAKG;IACI,MAAM,CAAC,kBAAkB,CAC9B,UAA8B;QAE9B,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;YACtC,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,MAAM,GAAiC,UAAU,CAAC,UAAU,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;QACpD,CAAC;QAED,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,CAAiB,EAAE,EAAE;YACtC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,qBAAqB,CACjC,UAA8B;QAE9B,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;YACtC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,MAAM,GAAiC,UAAU,CAAC,UAAU,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,MAAM,GAAG,GAA0B,sBAAsB,CACvD,UAAU,EACV,MAAM,CACP,CAAC;QACF,OAAO,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,KAAK,KAAI,UAAU,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,mBAAmB,CAAC,KAIjC;QACC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;QAE9C,IAAI,CAAC,QAAQ,IAAI,CAAC,UAAU,EAAE,CAAC;YAC7B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YAClD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,MAAM,GAAiC,UAAU,CAAC,UAAU,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAA0B,sBAAsB,CAC3D,QAAQ,EACR,MAAM,CACP,CAAC;QACF,MAAM,SAAS,GAA0B,sBAAsB,CAC7D,UAAU,EACV,MAAM,CACP,CAAC;QAEF,IAAI,CAAC,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;YAC3B,OAAO,KAAK,CAAC;QACf,CAAC;QAED;;;WAGG;QACH,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,uBAAuB,CACnC,UAA8B;QAE9B,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;YACtC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IACzC,CAAC;CACF"}

package/build/dist/Utils/Metrics/MetricFormulaEvaluator.js

@@ -0,0 +1,453 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+/**
+ * Shunting-yard based evaluator for metric formulas such as
+ * "$A + $B * 2" or "(a - b) / 100". Variables are matched by metric
+ * alias (case-insensitive, with or without a leading "$"). Evaluates
+ * the formula point-by-point against a time-aligned series from the
+ * referenced queries/formulas.
+ */
+var TokenType;
+(function (TokenType) {
+    TokenType["Number"] = "number";
+    TokenType["Variable"] = "variable";
+    TokenType["Operator"] = "operator";
+    TokenType["LeftParen"] = "lparen";
+    TokenType["RightParen"] = "rparen";
+})(TokenType || (TokenType = {}));
+const OPERATOR_PRECEDENCE = {
+    "u-": 4,
+    "u+": 4,
+    "^": 3,
+    "*": 2,
+    "/": 2,
+    "%": 2,
+    "+": 1,
+    "-": 1,
+};
+const RIGHT_ASSOCIATIVE = new Set(["^", "u-", "u+"]);
+export default class MetricFormulaEvaluator {
+    /**
+     * Evaluate a formula against the provided query/formula results and
+     * return a synthetic AggregatedResult whose timestamps are the union
+     * of all referenced series.
+     */
+    static evaluateFormula(input) {
+        const trimmedFormula = (input.formula || "").trim();
+        if (!trimmedFormula) {
+            return { data: [] };
+        }
+        const rpn = MetricFormulaEvaluator.toRpn(trimmedFormula);
+        const variableResults = MetricFormulaEvaluator.buildVariableResultMap({
+            queryConfigs: input.queryConfigs,
+            formulaConfigs: input.formulaConfigs,
+            results: input.results,
+        });
+        /*
+         * Validate every variable referenced in the formula actually resolves
+         * to a result series. Failing loudly is better than silently returning
+         * NaN when a user typos an alias.
+         */
+        const referencedVariables = MetricFormulaEvaluator.collectVariableNames(rpn);
+        for (const variableName of referencedVariables) {
+            if (!variableResults[variableName]) {
+                throw new BadDataException(`Formula references unknown variable "$${variableName}". Define a metric query with that alias first.`);
+            }
+        }
+        const timestampIndex = MetricFormulaEvaluator.buildTimestampIndex(referencedVariables, variableResults);
+        const sortedTimestamps = Array.from(timestampIndex.keys()).sort();
+        const resultData = [];
+        for (const timestampString of sortedTimestamps) {
+            const values = timestampIndex.get(timestampString) || {};
+            /*
+             * Skip points where any referenced variable is missing a value. A
+             * partial join would produce misleading numbers (e.g. treating a
+             * gap as zero silently when using subtraction).
+             */
+            const hasAllValues = referencedVariables.every((variable) => {
+                return typeof values[variable] === "number";
+            });
+            if (!hasAllValues) {
+                continue;
+            }
+            let evaluated;
+            try {
+                evaluated = MetricFormulaEvaluator.evaluateRpn(rpn, values);
+            }
+            catch (_a) {
+                continue;
+            }
+            if (!Number.isFinite(evaluated)) {
+                continue;
+            }
+            resultData.push({
+                timestamp: new Date(timestampString),
+                value: evaluated,
+            });
+        }
+        return { data: resultData };
+    }
+    /**
+     * Return the set of variables referenced by a formula, preserving the
+     * order of first appearance. Variable names are lower-cased to match
+     * the evaluator's case-insensitive lookup. Invalid formulas return an
+     * empty list rather than throwing, so callers rendering UI don't have
+     * to add defensive try/catch.
+     */
+    static getReferencedVariables(formula) {
+        const trimmedFormula = (formula || "").trim();
+        if (!trimmedFormula) {
+            return [];
+        }
+        try {
+            const rpn = MetricFormulaEvaluator.toRpn(trimmedFormula);
+            return MetricFormulaEvaluator.collectVariableNames(rpn);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    /**
+     * Validate a formula's syntax without evaluating it. Returns `null`
+     * when valid, otherwise a human-readable error message.
+     */
+    static validateFormula(input) {
+        const trimmedFormula = (input.formula || "").trim();
+        if (!trimmedFormula) {
+            return "Formula is required.";
+        }
+        let rpn;
+        try {
+            rpn = MetricFormulaEvaluator.toRpn(trimmedFormula);
+        }
+        catch (err) {
+            return err.message || "Invalid formula.";
+        }
+        const referenced = MetricFormulaEvaluator.collectVariableNames(rpn);
+        const available = new Set(input.availableVariables.map((v) => {
+            return v.toLowerCase();
+        }));
+        for (const variable of referenced) {
+            if (!available.has(variable.toLowerCase())) {
+                return `Formula references unknown variable "$${variable}".`;
+            }
+        }
+        return null;
+    }
+    static buildVariableResultMap(input) {
+        var _a, _b, _c, _d;
+        const variableMap = {};
+        const totalSeries = input.queryConfigs.length + input.formulaConfigs.length;
+        for (let index = 0; index < totalSeries; index++) {
+            const result = input.results[index];
+            if (!result) {
+                continue;
+            }
+            let alias;
+            if (index < input.queryConfigs.length) {
+                alias =
+                    ((_b = (_a = input.queryConfigs[index]) === null || _a === void 0 ? void 0 : _a.metricAliasData) === null || _b === void 0 ? void 0 : _b.metricVariable) ||
+                        undefined;
+            }
+            else {
+                const formulaIndex = index - input.queryConfigs.length;
+                alias =
+                    ((_d = (_c = input.formulaConfigs[formulaIndex]) === null || _c === void 0 ? void 0 : _c.metricAliasData) === null || _d === void 0 ? void 0 : _d.metricVariable) ||
+                        undefined;
+            }
+            if (!alias) {
+                continue;
+            }
+            variableMap[alias.toLowerCase()] = result;
+        }
+        return variableMap;
+    }
+    static buildTimestampIndex(variables, variableResults) {
+        const index = new Map();
+        for (const variable of variables) {
+            const series = variableResults[variable];
+            if (!series) {
+                continue;
+            }
+            for (const sample of series.data) {
+                const timestampKey = MetricFormulaEvaluator.normalizeTimestamp(sample.timestamp);
+                if (!index.has(timestampKey)) {
+                    index.set(timestampKey, {});
+                }
+                const bucket = index.get(timestampKey) || {};
+                bucket[variable] = sample.value;
+            }
+        }
+        return index;
+    }
+    static normalizeTimestamp(timestamp) {
+        if (timestamp instanceof Date) {
+            return timestamp.toISOString();
+        }
+        /*
+         * ClickHouse sometimes returns timestamps at varying precisions
+         * ("2024-01-01T00:00:00" vs "2024-01-01T00:00:00.000Z"). Normalize
+         * by parsing through Date so differently formatted strings for the
+         * same instant align correctly.
+         */
+        const asDate = new Date(timestamp);
+        if (!isNaN(asDate.getTime())) {
+            return asDate.toISOString();
+        }
+        return String(timestamp);
+    }
+    static collectVariableNames(rpn) {
+        const seen = new Set();
+        const result = [];
+        for (const token of rpn) {
+            if (token.type === TokenType.Variable) {
+                const normalized = token.value.toLowerCase();
+                if (!seen.has(normalized)) {
+                    seen.add(normalized);
+                    result.push(normalized);
+                }
+            }
+        }
+        return result;
+    }
+    static tokenize(expression) {
+        const tokens = [];
+        let position = 0;
+        while (position < expression.length) {
+            const char = expression[position];
+            if (char === " " || char === "\t" || char === "\n") {
+                position++;
+                continue;
+            }
+            // Number literal (with optional decimal and exponent)
+            if (char >= "0" && char <= "9") {
+                let numberBuffer = "";
+                while (position < expression.length &&
+                    MetricFormulaEvaluator.isNumberChar(expression[position], numberBuffer)) {
+                    numberBuffer += expression[position];
+                    position++;
+                }
+                tokens.push({ type: TokenType.Number, value: numberBuffer });
+                continue;
+            }
+            // Decimal starting without leading 0 (e.g. ".5")
+            if (char === "." &&
+                position + 1 < expression.length &&
+                expression[position + 1] >= "0" &&
+                expression[position + 1] <= "9") {
+                let numberBuffer = "";
+                while (position < expression.length &&
+                    MetricFormulaEvaluator.isNumberChar(expression[position], numberBuffer)) {
+                    numberBuffer += expression[position];
+                    position++;
+                }
+                tokens.push({ type: TokenType.Number, value: numberBuffer });
+                continue;
+            }
+            // Variable — may be prefixed with "$" or bare ("a", "b1", etc.)
+            if (char === "$" || MetricFormulaEvaluator.isIdentifierStart(char)) {
+                if (char === "$") {
+                    position++;
+                }
+                let identifier = "";
+                while (position < expression.length &&
+                    MetricFormulaEvaluator.isIdentifierPart(expression[position])) {
+                    identifier += expression[position];
+                    position++;
+                }
+                if (!identifier) {
+                    throw new BadDataException(`Unexpected character "$" without a variable name.`);
+                }
+                tokens.push({ type: TokenType.Variable, value: identifier });
+                continue;
+            }
+            if (char === "(") {
+                tokens.push({ type: TokenType.LeftParen, value: char });
+                position++;
+                continue;
+            }
+            if (char === ")") {
+                tokens.push({ type: TokenType.RightParen, value: char });
+                position++;
+                continue;
+            }
+            if (char === "+" ||
+                char === "-" ||
+                char === "*" ||
+                char === "/" ||
+                char === "%" ||
+                char === "^") {
+                tokens.push({ type: TokenType.Operator, value: char });
+                position++;
+                continue;
+            }
+            throw new BadDataException(`Unexpected character "${char}" at position ${position}.`);
+        }
+        return tokens;
+    }
+    static isNumberChar(char, currentBuffer) {
+        if (char >= "0" && char <= "9") {
+            return true;
+        }
+        if (char === "." && !currentBuffer.includes(".")) {
+            return true;
+        }
+        if ((char === "e" || char === "E") &&
+            !currentBuffer.toLowerCase().includes("e") &&
+            currentBuffer.length > 0) {
+            return true;
+        }
+        if ((char === "+" || char === "-") &&
+            currentBuffer.length > 0 &&
+            (currentBuffer[currentBuffer.length - 1] === "e" ||
+                currentBuffer[currentBuffer.length - 1] === "E")) {
+            return true;
+        }
+        return false;
+    }
+    static isIdentifierStart(char) {
+        return ((char >= "a" && char <= "z") ||
+            (char >= "A" && char <= "Z") ||
+            char === "_");
+    }
+    static isIdentifierPart(char) {
+        return (MetricFormulaEvaluator.isIdentifierStart(char) ||
+            (char >= "0" && char <= "9"));
+    }
+    static toRpn(expression) {
+        const tokens = MetricFormulaEvaluator.tokenize(expression);
+        const output = [];
+        const operatorStack = [];
+        let previousToken = null;
+        for (const token of tokens) {
+            if (token.type === TokenType.Number) {
+                output.push(token);
+            }
+            else if (token.type === TokenType.Variable) {
+                output.push(token);
+            }
+            else if (token.type === TokenType.Operator) {
+                let operatorValue = token.value;
+                const isUnary = (operatorValue === "+" || operatorValue === "-") &&
+                    (previousToken === null ||
+                        previousToken.type === TokenType.Operator ||
+                        previousToken.type === TokenType.LeftParen);
+                if (isUnary) {
+                    operatorValue = operatorValue === "-" ? "u-" : "u+";
+                }
+                while (operatorStack.length > 0) {
+                    const top = operatorStack[operatorStack.length - 1];
+                    if (top.type !== TokenType.Operator) {
+                        break;
+                    }
+                    const topPrecedence = OPERATOR_PRECEDENCE[top.value];
+                    const currentPrecedence = OPERATOR_PRECEDENCE[operatorValue];
+                    const isRightAssociative = RIGHT_ASSOCIATIVE.has(operatorValue);
+                    if (topPrecedence > currentPrecedence ||
+                        (topPrecedence === currentPrecedence && !isRightAssociative)) {
+                        output.push(operatorStack.pop());
+                    }
+                    else {
+                        break;
+                    }
+                }
+                operatorStack.push({ type: TokenType.Operator, value: operatorValue });
+            }
+            else if (token.type === TokenType.LeftParen) {
+                operatorStack.push(token);
+            }
+            else if (token.type === TokenType.RightParen) {
+                let foundLeftParen = false;
+                while (operatorStack.length > 0) {
+                    const top = operatorStack.pop();
+                    if (top.type === TokenType.LeftParen) {
+                        foundLeftParen = true;
+                        break;
+                    }
+                    output.push(top);
+                }
+                if (!foundLeftParen) {
+                    throw new BadDataException("Mismatched parentheses in formula.");
+                }
+            }
+            previousToken = token;
+        }
+        while (operatorStack.length > 0) {
+            const top = operatorStack.pop();
+            if (top.type === TokenType.LeftParen ||
+                top.type === TokenType.RightParen) {
+                throw new BadDataException("Mismatched parentheses in formula.");
+            }
+            output.push(top);
+        }
+        return output;
+    }
+    static evaluateRpn(rpn, variableValues) {
+        const stack = [];
+        for (const token of rpn) {
+            if (token.type === TokenType.Number) {
+                stack.push(parseFloat(token.value));
+                continue;
+            }
+            if (token.type === TokenType.Variable) {
+                const variableName = token.value.toLowerCase();
+                const variableValue = variableValues[variableName];
+                if (typeof variableValue !== "number") {
+                    throw new BadDataException(`Missing value for variable "${variableName}".`);
+                }
+                stack.push(variableValue);
+                continue;
+            }
+            if (token.type === TokenType.Operator) {
+                const operatorValue = token.value;
+                if (operatorValue === "u-" || operatorValue === "u+") {
+                    const operand = stack.pop();
+                    if (typeof operand !== "number") {
+                        throw new BadDataException("Invalid formula: missing operand.");
+                    }
+                    stack.push(operatorValue === "u-" ? -operand : operand);
+                    continue;
+                }
+                const right = stack.pop();
+                const left = stack.pop();
+                if (typeof right !== "number" || typeof left !== "number") {
+                    throw new BadDataException("Invalid formula: missing operands.");
+                }
+                switch (operatorValue) {
+                    case "+":
+                        stack.push(left + right);
+                        break;
+                    case "-":
+                        stack.push(left - right);
+                        break;
+                    case "*":
+                        stack.push(left * right);
+                        break;
+                    case "/":
+                        if (right === 0) {
+                            stack.push(NaN);
+                        }
+                        else {
+                            stack.push(left / right);
+                        }
+                        break;
+                    case "%":
+                        if (right === 0) {
+                            stack.push(NaN);
+                        }
+                        else {
+                            stack.push(left % right);
+                        }
+                        break;
+                    case "^":
+                        stack.push(Math.pow(left, right));
+                        break;
+                }
+            }
+        }
+        if (stack.length !== 1) {
+            throw new BadDataException("Invalid formula expression.");
+        }
+        return stack[0];
+    }
+}
+//# sourceMappingURL=MetricFormulaEvaluator.js.map