@oneuptime/common 12.0.34 → 13.0.0

package/Utils/Monitor/DeviceMacLearningUtil.ts

@@ -0,0 +1,177 @@
+import { normalizeMac } from "./EndpointAttachmentUtil";
+
+/*
+ * Pure planner for learning a managed device's MAC address from a walked
+ * router's ARP table.
+ *
+ * WHY. A ping-only device is put on its switch port by the switch's
+ * forwarding table, which knows MACs and nothing else - and a ping-only
+ * device is exactly the device nothing ever asked for its MAC. A router's
+ * ARP table is the bridge: it binds the address the device is registered at
+ * to the MAC the switches learned. Writing that MAC onto the device once is
+ * what keeps the device on its port after the ARP entry ages out, and after
+ * the address changes.
+ *
+ * Deterministic and side-effect free, like EndpointAttachmentUtil: the
+ * server util (NetworkDeviceMacLearningUtil) fetches the candidate devices,
+ * hands them here, and applies whatever comes back.
+ */
+
+export interface MacLearningIpBinding {
+  macAddress: string;
+  ipAddress: string;
+}
+
+// One NetworkDevice row, reduced to what the plan needs.
+export interface MacLearningCandidateDevice {
+  id: string;
+  hostname?: string | undefined;
+  // A string, never an ObjectID: the plan keys on it.
+  siteId?: string | undefined;
+  macAddress?: string | undefined;
+  /*
+   * True when the stored MAC was written by an earlier pass rather than
+   * typed. Only such a value may be corrected; a typed one is never touched.
+   */
+  isMacAddressLearned?: boolean | undefined;
+}
+
+export interface MacLearningPlanEntry {
+  deviceId: string;
+  macAddress: string;
+  ipAddress: string;
+  /*
+   * What the column held when the plan was made: null for an empty column,
+   * the previously learned MAC for a correction. The writer compares-and-
+   * sets against it, so a value that changed under the plan is left alone.
+   */
+  previousMacAddress: string | null;
+}
+
+/*
+ * null, undefined, "" and whitespace all read as the same "no site" key -
+ * the convention NetworkDeviceLinkRuleUtil and the topology builder use.
+ */
+export function siteKeyOf(siteId: string | null | undefined): string {
+  return (siteId || "").trim();
+}
+
+export default class DeviceMacLearningUtil {
+  /*
+   * Which devices get which MAC. The rules, every one of them a refusal:
+   *
+   *  - Only a device in the SAME site as the router that reported the
+   *    binding. Every branch has a 10.0.0.5; a project-wide match would
+   *    stamp one store's register with another store's MAC.
+   *  - Only a device whose MAC column is EMPTY, or holds a MAC an earlier
+   *    pass LEARNED that this table now contradicts. What an operator typed
+   *    is theirs and is never touched. A learned value is the pass's own
+   *    answer, and an ARP table is exactly the evidence that can be stale
+   *    (an address re-leased the day before the register was plugged in
+   *    stamps the previous holder's MAC), so the pass corrects itself when
+   *    the address is later bound to a different MAC.
+   *  - Only an address exactly one candidate device answers at. Two
+   *    devices registered at one address is a contradiction, and a wrong
+   *    MAC drawn as a cable is worse than none.
+   *  - Only an address the ARP table binds to exactly one MAC. Proxy ARP
+   *    and stale duplicates put two MACs behind one address; neither can
+   *    be trusted.
+   *
+   * Output is sorted by device id, so a given input always plans the same
+   * writes in the same order.
+   */
+  public static planMacLearning(data: {
+    ipBindings: Array<MacLearningIpBinding>;
+    devices: Array<MacLearningCandidateDevice>;
+    observingSiteId?: string | null | undefined;
+  }): Array<MacLearningPlanEntry> {
+    const macsByIp: Map<string, Set<string>> = new Map<string, Set<string>>();
+    for (const binding of data.ipBindings) {
+      const mac: string | undefined = normalizeMac(binding.macAddress);
+      const ip: string = (binding.ipAddress || "").trim();
+      if (!mac || !ip) {
+        continue;
+      }
+      const macs: Set<string> | undefined = macsByIp.get(ip);
+      if (macs) {
+        macs.add(mac);
+      } else {
+        macsByIp.set(ip, new Set<string>([mac]));
+      }
+    }
+
+    const siteKey: string = siteKeyOf(data.observingSiteId);
+
+    const devicesByIp: Map<string, Array<MacLearningCandidateDevice>> = new Map<
+      string,
+      Array<MacLearningCandidateDevice>
+    >();
+    for (const device of data.devices) {
+      const hostname: string = (device.hostname || "").trim();
+      if (!hostname || !macsByIp.has(hostname)) {
+        continue;
+      }
+      if (siteKeyOf(device.siteId) !== siteKey) {
+        continue;
+      }
+      const bucket: Array<MacLearningCandidateDevice> | undefined =
+        devicesByIp.get(hostname);
+      if (bucket) {
+        bucket.push(device);
+      } else {
+        devicesByIp.set(hostname, [device]);
+      }
+    }
+
+    const plan: Array<MacLearningPlanEntry> = [];
+
+    for (const [ip, candidates] of devicesByIp) {
+      // Two devices at one address: neither can be the one.
+      if (candidates.length !== 1) {
+        continue;
+      }
+      const macs: Set<string> = macsByIp.get(ip)!;
+      // Two MACs behind one address: neither can be trusted.
+      if (macs.size !== 1) {
+        continue;
+      }
+      const device: MacLearningCandidateDevice = candidates[0]!;
+      const learnedMac: string = Array.from(macs)[0]!;
+      const storedMac: string | undefined = normalizeMac(device.macAddress);
+      const hasStoredValue: boolean =
+        (device.macAddress || "").trim().length > 0;
+
+      if (!hasStoredValue) {
+        plan.push({
+          deviceId: device.id,
+          macAddress: learnedMac,
+          ipAddress: ip,
+          previousMacAddress: null,
+        });
+        continue;
+      }
+
+      // Typed by somebody, or already what the table says: leave it.
+      if (device.isMacAddressLearned !== true || storedMac === learnedMac) {
+        continue;
+      }
+
+      plan.push({
+        deviceId: device.id,
+        macAddress: learnedMac,
+        ipAddress: ip,
+        /*
+         * The raw stored value, not the normalised one: the writer's
+         * compare-and-set has to match what the column actually holds.
+         */
+        previousMacAddress: device.macAddress || null,
+      });
+    }
+
+    plan.sort((a: MacLearningPlanEntry, b: MacLearningPlanEntry) => {
+      return a.deviceId < b.deviceId ? -1 : a.deviceId > b.deviceId ? 1 : 0;
+    });
+
+    return plan;
+  }
+}

package/Utils/Monitor/MetricValueFormatter.ts

@@ -0,0 +1,342 @@
+import MetricUnitUtil from "../MetricUnitUtil";
+import ValueFormatter from "../ValueFormatter";
+
+/*
+ * How a metric sample is written into alert / incident notification text.
+ *
+ * The dashboard has always scaled metric values before showing them —
+ * `ValueFormatter` turns 1073741824 bytes into "1.07 GB" for every chart,
+ * gauge and value tile. The notification path never did. The same memory
+ * breach that reads "1.07 GB" on the monitor page arrived in the on-call
+ * engineer's inbox as the bare digits "1073741824 By", and in the
+ * "Affected Resources" tables as a Value column with no unit at all — a
+ * column of ten-digit numbers the reader has to divide by 2^30 in their
+ * head at 3am to find out whether the pod is anywhere near its limit.
+ *
+ * This module is the single place that decides how a (value, unit) pair
+ * is rendered for a notification, so the breaching-samples table, the
+ * "Filter Conditions Met" sentence, the observation summary and the
+ * per-platform resource tables cannot drift apart inside one email.
+ *
+ * WHY IT WRAPS ValueFormatter RATHER THAN BEING A CALL TO IT.
+ *
+ * Three things differ between a chart axis and an alert body:
+ *
+ *  1. ABBREVIATION. `ValueFormatter` shortens any number over 1000 to
+ *     "1.5K" — right for a tick label, which has no horizontal room, and
+ *     wrong for an alert, where "restarted 1.5K times" hides the
+ *     difference between 1500 and 1549 that the reader opened the table
+ *     to find. Here, only a unit that names an actual SCALE LADDER
+ *     (bytes → KB → MB, seconds → min → hours) may rescale a number.
+ *     Everything else keeps its digits and simply gets its unit spelled
+ *     out: "1234567 cores", not "1.23M cores".
+ *
+ *  2. PREFIXED UNITS. A user who typed a threshold in "GB" makes every
+ *     sample arrive carrying the unit "GB", and ValueFormatter has a
+ *     ladder for "bytes" but not for "GB" — so 2500 of them rendered
+ *     "2.5K GB" instead of "2.5 TB". Anything in a MetricUnitUtil family
+ *     is converted to that family's base before the ladder runs.
+ *
+ *  3. UNITS WORTH HIDING. OTel's dimensionless "1" and UCUM's
+ *     annotation-only units ("{restarts}", "{packets}") are not
+ *     dimensions, and printing them produces the "0.06 1" that
+ *     CompareCriteria and MonitorCriteriaObservationBuilder each grew
+ *     their own guard against. That rule lives here now.
+ */
+export default class MetricValueFormatter {
+  /*
+   * UCUM annotation-only units — "{thread}", "{packets}", "{errors}".
+   * The braces describe what is being counted; the value is a plain
+   * count and the text inside them is not a unit a reader should see.
+   */
+  private static readonly annotationOnlyUnitPattern: RegExp = /^\{[^{}]*\}$/;
+
+  /*
+   * The per-platform metric catalogs (Kubernetes, Ceph, Proxmox, Docker
+   * Swarm) were written for humans reading a metric picker, so they spell
+   * two dimensionless concepts in English rather than in UCUM. "count"
+   * appears on 43 catalog entries and means exactly what UCUM's "1" means
+   * on a counter — printing it gives "15 count", which reads as a typo.
+   * "ratio" means what UCUM's "1" means on a fraction metric: a value in
+   * [0, 1] that a reader wants as a percentage.
+   *
+   * Rewriting them here rather than in each catalog keeps the catalogs
+   * legible to the people who edit them and still gives every consumer of
+   * this formatter one vocabulary.
+   */
+  private static readonly informalUnitAliases: Record<string, string> = {
+    count: "",
+    counts: "",
+    ratio: "1",
+    fraction: "1",
+  };
+
+  /*
+   * Metrics whose unit says "seconds" but whose VALUE is a POINT in time
+   * rather than a length of one.
+   *
+   * Proxmox has three: pve_replication_last_sync_timestamp_seconds,
+   * _last_try_ and _next_sync_ — all carrying `unit: "seconds"`, all
+   * holding a Unix epoch. Sent through the duration ladder, an epoch of
+   * 1750000000 renders "20.25K days", which is not merely unhelpful: it
+   * READS as a duration, so a replication job that synced a minute ago
+   * looks 55 years stale. The bare number at least cannot be misread as
+   * something it is not.
+   *
+   * Same shape as ValueFormatter's kubeletstats exclusion: a narrow,
+   * name-anchored carve-out for a unit the exporter declared wrongly.
+   */
+  private static readonly absoluteTimestampMetricPattern: RegExp =
+    /(^|[._])timestamps?([._]seconds?)?$/i;
+
+  /**
+   * Whether `unit` names a real dimension for `metricName` — i.e. whether
+   * it is worth attaching to a number at all. False for the empty unit,
+   * for the dimensionless "1" on a non-fraction metric, and for
+   * annotation-only units.
+   */
+  public static hasDisplayableUnit(
+    unit: string | null | undefined,
+    metricName?: string | null | undefined,
+  ): boolean {
+    const trimmed: string = MetricValueFormatter.canonicalizeUnit(unit);
+
+    if (!trimmed) {
+      return false;
+    }
+
+    /*
+     * "1" is OTel's dimensionless marker. On a `.utilization` / `.ratio`
+     * metric it means "this is a [0, 1] fraction", which IS a scale (× 100
+     * into a percent) and is why the fraction case is excluded here rather
+     * than folded in. On anything else it is noise: "0.06 1" is not just
+     * ugly, it reads as 1% when the value is 6%.
+     */
+    if (trimmed === "1") {
+      return ValueFormatter.isFractionMetric(metricName || undefined);
+    }
+
+    return !MetricValueFormatter.annotationOnlyUnitPattern.test(trimmed);
+  }
+
+  /**
+   * Format one metric sample for a notification.
+   *
+   * Units with a scale ladder are rescaled, exactly as the dashboard does:
+   *   format({ value: 1073741824, unit: "By" })            → "1.07 GB"
+   *   format({ value: 2500, unit: "GB" })                  → "2.5 TB"
+   *   format({ value: 1500, unit: "ms" })                  → "1.5 sec"
+   *   format({ value: 3661, unit: "seconds" })             → "1.02 hours"
+   *   format({ value: 1500000, unit: "By/s" })             → "1.5 MB/s"
+   *   format({ value: 0.2534, unit: "1",
+   *            metricName: "system.cpu.utilization" })     → "25.34%"
+   *   format({ value: 87.5, unit: "%" })                   → "87.50%"
+   *
+   * Units without one keep every digit and are merely labelled:
+   *   format({ value: 1234567, unit: "cores" })            → "1234567 cores"
+   *   format({ value: 95, unit: "Cel" })                   → "95 Celsius"
+   *
+   * A value with no dimension to report is left bare:
+   *   format({ value: 1500 })                              → "1500"
+   *   format({ value: 1500, unit: "{restarts}" })          → "1500"
+   *   format({ value: 3.14159 })                           → "3.14"
+   */
+  public static format(input: {
+    value: number;
+    unit?: string | null | undefined;
+    metricName?: string | null | undefined;
+  }): string {
+    if (!Number.isFinite(input.value)) {
+      return String(input.value);
+    }
+
+    const unit: string = MetricValueFormatter.canonicalizeUnit(input.unit);
+    const metricName: string | undefined = input.metricName || undefined;
+
+    if (!MetricValueFormatter.hasDisplayableUnit(unit, metricName)) {
+      return MetricValueFormatter.formatBareNumber(input.value);
+    }
+
+    const formatOptions: { metricName?: string } = metricName
+      ? { metricName: metricName }
+      : {};
+
+    /*
+     * Percent first. ValueFormatter renders "%" and the fraction-metric
+     * "1" as a two-decimal percentage, and neither is reachable through
+     * the ladder path below (there is no percent threshold table, and the
+     * percent family's base unit "%" has no ladder either).
+     */
+    if (
+      ValueFormatter.isPercentUnit(unit) ||
+      (unit === "1" && ValueFormatter.isFractionMetric(metricName))
+    ) {
+      return ValueFormatter.formatValue(input.value, unit, formatOptions);
+    }
+
+    const scalable: { value: number; unit: string } | null =
+      MetricValueFormatter.isAbsoluteTimestampMetric(metricName)
+        ? null
+        : MetricValueFormatter.toScalableUnit(input.value, unit);
+
+    if (scalable) {
+      return ValueFormatter.formatValue(
+        scalable.value,
+        scalable.unit,
+        formatOptions,
+      );
+    }
+
+    /*
+     * No ladder for this unit: label the number, leave its digits alone.
+     *
+     * The SYMBOL rather than the spelled-out name, because this suffix
+     * sits directly against a number, where the ladder path also emits
+     * symbols ("1.07 GB", "1.5 sec"). getReadableUnit is for the "Unit:"
+     * label line, where a name reads better than a code — and it is
+     * actively wrong here for compound units, which it rewrites: "m/s2"
+     * becomes "m per s2" and "10*3/uL" becomes "10*3 per uL", both longer
+     * and less recognisable than what the exporter wrote. getCompactUnit
+     * keeps the slash and still expands what is worth expanding
+     * ("Cel" → "°C", "KiBy" → "KiB").
+     */
+    const unitSymbol: string =
+      ValueFormatter.getCompactUnit(unit, formatOptions) || unit;
+
+    return `${MetricValueFormatter.formatBareNumber(input.value)} ${unitSymbol}`;
+  }
+
+  /**
+   * The spelled-out name of a unit, for the "Unit:" line of a root cause —
+   * "Bytes" rather than the UCUM "By" the exporter wrote. Returns null when
+   * the unit names no dimension, so the caller can drop the line entirely
+   * instead of printing the noise "Unit: 1".
+   */
+  public static getReadableUnit(
+    unit: string | null | undefined,
+    metricName?: string | null | undefined,
+  ): string | null {
+    if (!MetricValueFormatter.hasDisplayableUnit(unit, metricName)) {
+      return null;
+    }
+
+    const readable: string = ValueFormatter.getReadableUnit(
+      MetricValueFormatter.canonicalizeUnit(unit),
+      metricName ? { metricName: metricName } : {},
+    );
+
+    return readable.trim() ? readable : null;
+  }
+
+  /*
+   * Trim the unit and rewrite the catalogs' English spellings of "no
+   * dimension" into the UCUM ones the rest of the pipeline understands.
+   * Anything else is returned untouched — including its casing, which
+   * matters because an unrecognised unit is echoed verbatim next to the
+   * value ("5 widgets", not "5 Widgets").
+   */
+  private static canonicalizeUnit(unit: string | null | undefined): string {
+    const trimmed: string = (unit || "").trim();
+
+    if (!trimmed) {
+      return "";
+    }
+
+    const alias: string | undefined =
+      MetricValueFormatter.informalUnitAliases[trimmed.toLowerCase()];
+
+    return alias === undefined ? trimmed : alias;
+  }
+
+  /**
+   * Whether this metric's value is a point in time rather than a quantity,
+   * and so must never be run through a scale ladder. See
+   * absoluteTimestampMetricPattern.
+   */
+  public static isAbsoluteTimestampMetric(
+    metricName: string | null | undefined,
+  ): boolean {
+    if (!metricName) {
+      return false;
+    }
+
+    return MetricValueFormatter.absoluteTimestampMetricPattern.test(
+      metricName.trim(),
+    );
+  }
+
+  /*
+   * Restate (value, unit) in a unit ValueFormatter has a scale ladder for,
+   * or return null when no ladder can apply.
+   *
+   * Three ways a unit gets there:
+   *   - it already has one ("bytes", "ms", "s", "ns");
+   *   - it is a rate whose NUMERATOR does ("By/s" → scale the bytes, keep
+   *     the "/s"), which is how 1500000 By/s reads "1.5 MB/s";
+   *   - it is a prefixed member of a MetricUnitUtil family ("GB", "hours"),
+   *     in which case the value is converted into that family's base first.
+   */
+  private static toScalableUnit(
+    value: number,
+    unit: string,
+  ): { value: number; unit: string } | null {
+    if (!unit) {
+      return null;
+    }
+
+    if (ValueFormatter.isScalableUnit(unit)) {
+      return { value: value, unit: unit };
+    }
+
+    if (unit.includes("/")) {
+      const [numerator, ...denominatorParts] = unit.split("/");
+      const denominator: string = denominatorParts.join("/").trim();
+
+      if (!numerator || !numerator.trim() || !denominator) {
+        return null;
+      }
+
+      const scaledNumerator: { value: number; unit: string } | null =
+        MetricValueFormatter.toScalableUnit(value, numerator.trim());
+
+      if (!scaledNumerator) {
+        return null;
+      }
+
+      return {
+        value: scaledNumerator.value,
+        unit: `${scaledNumerator.unit}/${denominator}`,
+      };
+    }
+
+    const baseUnit: string | null = MetricUnitUtil.getFamilyBaseUnit(unit);
+
+    if (!baseUnit || !ValueFormatter.isScalableUnit(baseUnit)) {
+      return null;
+    }
+
+    return {
+      value: MetricUnitUtil.convertToMetricUnit({
+        value: value,
+        fromUnit: unit,
+        metricUnit: baseUnit,
+      }),
+      unit: baseUnit,
+    };
+  }
+
+  /*
+   * The unscaled rendering: integers verbatim, everything else rounded to
+   * two decimals with trailing zeros dropped (1.50 → "1.5"). This is the
+   * behaviour the root-cause tables had before units arrived, and every
+   * value without a scale ladder keeps it exactly, so a counter's digits
+   * survive the trip to the inbox.
+   */
+  private static formatBareNumber(value: number): string {
+    if (Number.isInteger(value)) {
+      return value.toString();
+    }
+
+    return Number(value.toFixed(2)).toString();
+  }
+}

package/Utils/Monitor/MonitorTemplateCustomFieldUtil.ts

@@ -0,0 +1,124 @@
+import { JSONObject, JSONValue } from "../../Types/JSON";
+import JSONFunctions from "../../Types/JSONFunctions";
+
+/*
+ * WHAT A MONITOR TEMPLATE'S CUSTOM FIELDS MEAN, in one place.
+ *
+ * A template's `customFields` bag is a set of DEFAULTS for the monitors made
+ * from it — the answer to issue #3548, where an auto-import rule turned a
+ * thousand discovered devices into a thousand monitors whose Vendor, Services
+ * and Configuration Item fields were all empty and could only be filled in one
+ * monitor at a time.
+ *
+ * Two callers need the same answer and would drift apart if each wrote its
+ * own:
+ *
+ *   - PROVISIONING (NetworkDeviceMonitorTemplateUtil.buildMonitor, reached
+ *     from the auto-import engine and the alert-policy engine) starts from a
+ *     monitor with no values at all, so it takes the whole bag.
+ *   - SYNC (MonitorTemplateService) pushes the template onto monitors that
+ *     already exist and may already carry values an operator typed in, so it
+ *     OVERLAYS instead: every field the template actually gives a default for
+ *     wins, and every other field on the monitor is left exactly as it is.
+ *
+ * Both go through a deep clone, because a jsonb bag handed to several monitors
+ * by reference is one nested edit away from leaking across the fleet — and
+ * back onto the template itself.
+ */
+export default class MonitorTemplateCustomFieldUtil {
+  /*
+   * A defaults bag is only worth writing when there is a value in it, so
+   * "template has no defaults" and "template has an empty bag" are the same
+   * answer to every caller here. This is what keeps a sync scoped to custom
+   * fields alone from reporting that it wrote to a fleet it did not touch.
+   */
+  public static hasDefaults(
+    customFields: JSONObject | undefined | null,
+  ): boolean {
+    return Object.keys(this.getDefaults(customFields)).length > 0;
+  }
+
+  /*
+   * The template's defaults, deep-cloned, with the fields it does not actually
+   * default DROPPED.
+   *
+   * A template carries a key for every custom field the project has defined
+   * the moment somebody saves the edit form — the form submits its whole
+   * values object — so most keys in a freshly saved bag hold nothing. Left in,
+   * they would make a sync overwrite real per-monitor values with blanks: a
+   * template that only defaults Vendor would silently clear Configuration Item
+   * on every monitor in the fleet.
+   *
+   * `false` and `0` are values, not blanks — a Boolean custom field defaulting
+   * to false and a Number defaulting to 0 are both things an operator means.
+   */
+  public static getDefaults(
+    customFields: JSONObject | undefined | null,
+  ): JSONObject {
+    if (!customFields) {
+      return {};
+    }
+
+    const defaults: JSONObject = {};
+
+    for (const key of Object.keys(customFields)) {
+      const value: JSONValue = customFields[key] as JSONValue;
+
+      if (this.isBlank(value)) {
+        continue;
+      }
+
+      defaults[key] = value;
+    }
+
+    return this.clone(defaults);
+  }
+
+  /*
+   * Overlay the template's defaults onto the values a monitor already has.
+   * Returns a new bag; neither input is mutated.
+   */
+  public static applyDefaults(data: {
+    templateCustomFields: JSONObject | undefined | null;
+    monitorCustomFields: JSONObject | undefined | null;
+  }): JSONObject {
+    return {
+      ...this.clone(data.monitorCustomFields || {}),
+      ...this.getDefaults(data.templateCustomFields),
+    };
+  }
+
+  /*
+   * The whole bag, verbatim apart from being deep-cloned — blanks included.
+   *
+   * Provisioning uses this rather than getDefaults because there is nothing
+   * underneath to protect: a monitor being created has no values of its own,
+   * so a blank default and an absent one look identical on the monitor, and
+   * copying the bag as written keeps "what the template says" and "what the
+   * new monitor got" literally the same object.
+   */
+  public static clone(customFields: JSONObject): JSONObject {
+    return JSONFunctions.deserialize(JSONFunctions.serialize(customFields));
+  }
+
+  /*
+   * Nothing an operator would call a default. An empty multi-select arrives as
+   * [], a cleared text field as "" (or as spaces, from a form nobody trimmed),
+   * and a field never touched as null or undefined.
+   */
+  private static isBlank(value: JSONValue): boolean {
+    if (value === undefined || value === null) {
+      return true;
+    }
+
+    if (typeof value === "string") {
+      return value.trim() === "";
+    }
+
+    if (Array.isArray(value)) {
+      return value.length === 0;
+    }
+
+    return false;
+  }
+}

package/Utils/Monitor/NetworkDeviceMonitorTemplateUtil.ts

@@ -3,10 +3,10 @@ import MonitorTemplate from "../../Models/DatabaseModels/MonitorTemplate";
 import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
 import BadDataException from "../../Types/Exception/BadDataException";
 import { JSONObject } from "../../Types/JSON";
-import JSONFunctions from "../../Types/JSONFunctions";
 import MonitorSteps from "../../Types/Monitor/MonitorSteps";
 import MonitorType from "../../Types/Monitor/MonitorType";
 import ObjectID from "../../Types/ObjectID";
+import MonitorTemplateCustomFieldUtil from "./MonitorTemplateCustomFieldUtil";
 
 /*
  * Materialises a project MonitorTemplate for one discovered NetworkDevice.
@@ -379,7 +379,12 @@ export default class NetworkDeviceMonitorTemplateUtil {
     return truncated;
   }
 
+  /*
+   * Delegated so "what a template's custom fields mean" is written down once
+   * — provisioning takes the bag whole, sync overlays it. See
+   * MonitorTemplateCustomFieldUtil.
+   */
   private static cloneCustomFields(customFields: JSONObject): JSONObject {
-    return JSONFunctions.deserialize(JSONFunctions.serialize(customFields));
+    return MonitorTemplateCustomFieldUtil.clone(customFields);
   }
 }