@oneuptime/common 13.0.0 → 13.0.1

package/Types/Monitor/MonitorStep.ts

@@ -72,6 +72,9 @@ import MonitorStepPodmanMonitor, {
 import MonitorStepProxmoxMonitor, {
   MonitorStepProxmoxMonitorUtil,
 } from "./MonitorStepProxmoxMonitor";
+import MonitorStepVMwareMonitor, {
+  MonitorStepVMwareMonitorUtil,
+} from "./MonitorStepVMwareMonitor";
 import MonitorStepDockerSwarmMonitor, {
   MonitorStepDockerSwarmMonitorUtil,
 } from "./MonitorStepDockerSwarmMonitor";
@@ -84,6 +87,7 @@ import MonitorStepIoTMonitor, {
 import MetricsViewConfig from "../Metrics/MetricsViewConfig";
 import MetricQueryConfigData from "../Metrics/MetricQueryConfigData";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
+import MonitorTemplateSyncFieldUtil from "./MonitorTemplateSyncField";
 
 /*
  * Caps and defaults for per-step request timeout and retry settings.
@@ -120,6 +124,8 @@ export const clampMonitorRetryCount: (value: number) => number = (
 
 export interface MonitorStepType {
   id: string;
+  // Template policy: keep these fields from each linked monitor during sync.
+  doNotSyncFields?: Array<string> | undefined;
   monitorDestination?: URL | IP | Hostname | undefined;
 
   monitorCriteria: MonitorCriteria;
@@ -228,6 +234,9 @@ export interface MonitorStepType {
   // Proxmox monitor
   proxmoxMonitor?: MonitorStepProxmoxMonitor | undefined;
 
+  // VMware monitor
+  vmwareMonitor?: MonitorStepVMwareMonitor | undefined;
+
   // Docker Swarm monitor
   dockerSwarmMonitor?: MonitorStepDockerSwarmMonitor | undefined;
 
@@ -282,6 +291,7 @@ export default class MonitorStep extends DatabaseProperty {
       hostMonitor: undefined,
       podmanMonitor: undefined,
       proxmoxMonitor: undefined,
+      vmwareMonitor: undefined,
       dockerSwarmMonitor: undefined,
       cephMonitor: undefined,
       iotMonitor: undefined,
@@ -368,6 +378,7 @@ export default class MonitorStep extends DatabaseProperty {
       hostMonitor: undefined,
       podmanMonitor: undefined,
       proxmoxMonitor: undefined,
+      vmwareMonitor: undefined,
       dockerSwarmMonitor: undefined,
       cephMonitor: undefined,
       iotMonitor: undefined,
@@ -403,6 +414,7 @@ export default class MonitorStep extends DatabaseProperty {
       data.hostMonitor?.metricViewConfig ||
       data.podmanMonitor?.metricViewConfig ||
       data.proxmoxMonitor?.metricViewConfig ||
+      data.vmwareMonitor?.metricViewConfig ||
       data.cephMonitor?.metricViewConfig
     );
   }
@@ -684,6 +696,13 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setVMwareMonitor(
+    vmwareMonitor: MonitorStepVMwareMonitor,
+  ): MonitorStep {
+    this.data!.vmwareMonitor = vmwareMonitor;
+    return this;
+  }
+
   public setDockerSwarmMonitor(
     dockerSwarmMonitor: MonitorStepDockerSwarmMonitor,
   ): MonitorStep {
@@ -741,6 +760,7 @@ export default class MonitorStep extends DatabaseProperty {
         hostMonitor: undefined,
         podmanMonitor: undefined,
         proxmoxMonitor: undefined,
+        vmwareMonitor: undefined,
         dockerSwarmMonitor: undefined,
         cephMonitor: undefined,
         iotMonitor: undefined,
@@ -756,6 +776,15 @@ export default class MonitorStep extends DatabaseProperty {
       return "Monitor Step is required.";
     }
 
+    try {
+      MonitorTemplateSyncFieldUtil.parse(
+        value.data.doNotSyncFields,
+        monitorType,
+      );
+    } catch (error) {
+      return (error as Error).message;
+    }
+
     // If the monitor type is incoming request, then the monitor destination is not required
     if (
       !value.data.monitorDestination &&
@@ -996,6 +1025,16 @@ export default class MonitorStep extends DatabaseProperty {
       }
     }
 
+    if (monitorType === MonitorType.VMware) {
+      if (!value.data.vmwareMonitor) {
+        return "VMware monitor configuration is required";
+      }
+
+      if (!value.data.vmwareMonitor.vcenterIdentifier) {
+        return "vCenter is required";
+      }
+    }
+
     if (monitorType === MonitorType.DockerSwarm) {
       if (!value.data.dockerSwarmMonitor) {
         return "Docker Swarm monitor configuration is required";
@@ -1035,24 +1074,26 @@ export default class MonitorStep extends DatabaseProperty {
         _type: ObjectType.MonitorStep,
         value: {
           id: this.data.id,
+          doNotSyncFields: MonitorTemplateSyncFieldUtil.parse(
+            this.data.doNotSyncFields,
+          ),
           monitorDestination:
             this.data?.monitorDestination?.toJSON() || undefined,
-          doNotFollowRedirects: this.data.doNotFollowRedirects || undefined,
-          allowSelfSignedCertificates:
-            this.data.allowSelfSignedCertificates || undefined,
-          tlsClientCertificate: this.data.tlsClientCertificate || undefined,
-          tlsClientKey: this.data.tlsClientKey || undefined,
-          tlsClientKeyPassphrase: this.data.tlsClientKeyPassphrase || undefined,
+          doNotFollowRedirects: this.data.doNotFollowRedirects,
+          allowSelfSignedCertificates: this.data.allowSelfSignedCertificates,
+          tlsClientCertificate: this.data.tlsClientCertificate,
+          tlsClientKey: this.data.tlsClientKey,
+          tlsClientKeyPassphrase: this.data.tlsClientKeyPassphrase,
           monitorDestinationPort:
             this.data?.monitorDestinationPort?.toJSON() || undefined,
           monitorCriteria: this.data.monitorCriteria.toJSON(),
           requestType: this.data.requestType,
           requestHeaders: this.data.requestHeaders || undefined,
-          requestBody: this.data.requestBody || undefined,
-          customCode: this.data.customCode || undefined,
+          requestBody: this.data.requestBody,
+          customCode: this.data.customCode,
           screenSizeTypes: this.data.screenSizeTypes || undefined,
           browserTypes: this.data.browserTypes || undefined,
-          retryCountOnError: this.data.retryCountOnError || undefined,
+          retryCountOnError: this.data.retryCountOnError,
           requestTimeoutInMs: this.data.requestTimeoutInMs || undefined,
           retryCount:
             this.data.retryCount === undefined
@@ -1134,6 +1175,9 @@ export default class MonitorStep extends DatabaseProperty {
           proxmoxMonitor: this.data.proxmoxMonitor
             ? MonitorStepProxmoxMonitorUtil.toJSON(this.data.proxmoxMonitor)
             : undefined,
+          vmwareMonitor: this.data.vmwareMonitor
+            ? MonitorStepVMwareMonitorUtil.toJSON(this.data.vmwareMonitor)
+            : undefined,
           dockerSwarmMonitor: this.data.dockerSwarmMonitor
             ? MonitorStepDockerSwarmMonitorUtil.toJSON(
                 this.data.dockerSwarmMonitor,
@@ -1220,15 +1264,18 @@ export default class MonitorStep extends DatabaseProperty {
 
     monitorStep.data = JSONFunctions.deserialize({
       id: json["id"] as string,
+      doNotSyncFields: MonitorTemplateSyncFieldUtil.parse(
+        json["doNotSyncFields"],
+      ),
       monitorDestination: monitorDestination || undefined,
-      doNotFollowRedirects: json["doNotFollowRedirects"] || undefined,
+      doNotFollowRedirects: json["doNotFollowRedirects"] ?? undefined,
       allowSelfSignedCertificates:
-        json["allowSelfSignedCertificates"] || undefined,
+        json["allowSelfSignedCertificates"] ?? undefined,
       tlsClientCertificate:
-        (json["tlsClientCertificate"] as string) || undefined,
-      tlsClientKey: (json["tlsClientKey"] as string) || undefined,
+        (json["tlsClientCertificate"] as string) ?? undefined,
+      tlsClientKey: (json["tlsClientKey"] as string) ?? undefined,
       tlsClientKeyPassphrase:
-        (json["tlsClientKeyPassphrase"] as string) || undefined,
+        (json["tlsClientKeyPassphrase"] as string) ?? undefined,
       monitorDestinationPort: monitorDestinationPort || undefined,
       monitorCriteria: MonitorCriteria.fromJSON(
         json["monitorCriteria"] as JSONObject,
@@ -1236,12 +1283,12 @@ export default class MonitorStep extends DatabaseProperty {
       requestType: (json["requestType"] as HTTPMethod) || HTTPMethod.GET,
       requestHeaders:
         (json["requestHeaders"] as Dictionary<string>) || undefined,
-      requestBody: (json["requestBody"] as string) || undefined,
-      customCode: (json["customCode"] as string) || undefined,
+      requestBody: (json["requestBody"] as string) ?? undefined,
+      customCode: (json["customCode"] as string) ?? undefined,
       screenSizeTypes:
         (json["screenSizeTypes"] as Array<ScreenSizeType>) || undefined,
       browserTypes: (json["browserTypes"] as Array<BrowserType>) || undefined,
-      retryCountOnError: (json["retryCountOnError"] as number) || undefined,
+      retryCountOnError: (json["retryCountOnError"] as number) ?? undefined,
       requestTimeoutInMs: (json["requestTimeoutInMs"] as number) || undefined,
       retryCount:
         json["retryCount"] === undefined || json["retryCount"] === null
@@ -1343,6 +1390,9 @@ export default class MonitorStep extends DatabaseProperty {
       proxmoxMonitor: json["proxmoxMonitor"]
         ? (json["proxmoxMonitor"] as JSONObject)
         : undefined,
+      vmwareMonitor: json["vmwareMonitor"]
+        ? (json["vmwareMonitor"] as JSONObject)
+        : undefined,
       dockerSwarmMonitor: json["dockerSwarmMonitor"]
         ? (json["dockerSwarmMonitor"] as JSONObject)
         : undefined,
@@ -1362,6 +1412,16 @@ export default class MonitorStep extends DatabaseProperty {
       _type: Zod.literal(ObjectType.MonitorStep),
       value: Zod.object({
         id: Zod.string(),
+        doNotSyncFields: Zod.array(
+          Zod.string().refine((value: string): boolean => {
+            try {
+              MonitorTemplateSyncFieldUtil.parse([value]);
+              return true;
+            } catch {
+              return false;
+            }
+          }, "Unsupported do not sync field"),
+        ).optional(),
         monitorDestination: Zod.any().optional(),
         monitorCriteria: Zod.any(),
         requestType: Zod.any(),
@@ -1397,6 +1457,7 @@ export default class MonitorStep extends DatabaseProperty {
         hostMonitor: Zod.any().optional(),
         podmanMonitor: Zod.any().optional(),
         proxmoxMonitor: Zod.any().optional(),
+        vmwareMonitor: Zod.any().optional(),
         dockerSwarmMonitor: Zod.any().optional(),
         cephMonitor: Zod.any().optional(),
         iotMonitor: Zod.any().optional(),

package/Types/Monitor/MonitorStepMetricViewConfigUtil.ts

@@ -22,6 +22,7 @@ const METRIC_VIEW_CONFIG_KEYS: Array<keyof MonitorStepType> = [
   "dockerSwarmMonitor",
   "podmanMonitor",
   "proxmoxMonitor",
+  "vmwareMonitor",
   "cephMonitor",
   "iotMonitor",
 ];

package/Types/Monitor/MonitorStepVMwareMonitor.ts

@@ -0,0 +1,127 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+/**
+ * The kind of vSphere object a metric series belongs to.
+ *
+ * The OpenTelemetry Collector `vcenter` receiver emits one OTLP resource per
+ * vSphere object and identifies it through RESOURCE attributes
+ * (`vcenter.datacenter.name`, `vcenter.cluster.name`, `vcenter.host.name`,
+ * `vcenter.vm.name` / `vcenter.vm.id`, `vcenter.datastore.name`,
+ * `vcenter.resource_pool.inventory_path`). There is no agent-stamped scope
+ * attribute the way Proxmox has `pve.scope`, so this enum is a catalog /
+ * picker hint that says which identity attributes a metric carries — it is
+ * never sent to ClickHouse as a filter itself.
+ */
+export enum VMwareResourceScope {
+  VCenter = "vcenter",
+  Datacenter = "datacenter",
+  Cluster = "cluster",
+  Host = "host",
+  VirtualMachine = "vm",
+  Datastore = "datastore",
+  ResourcePool = "resource_pool",
+}
+
+/**
+ * The inventory row kinds `VMwareResource.kind` can hold. Kept next to the
+ * scope enum so the ingest scan, the inventory model description and the
+ * dashboard all reference the same literal strings.
+ *
+ * VM templates are VirtualMachine rows with `isTemplate = true`; vApps are
+ * not an inventory kind (vApp membership is a VM attribute only).
+ */
+export enum VMwareResourceKind {
+  Datacenter = "Datacenter",
+  Cluster = "Cluster",
+  Host = "Host",
+  VirtualMachine = "VirtualMachine",
+  Datastore = "Datastore",
+  ResourcePool = "ResourcePool",
+}
+
+/*
+ * Filter contract: every filter below is an equality on an OTel RESOURCE
+ * attribute, which OtelMetricsIngestService stores `resource.`-prefixed in
+ * ClickHouse. The monitor worker maps each field to its prefixed attribute
+ * (the arrow in each comment) and always adds
+ * `resource.vmware.vcenter.name = vcenterIdentifier` on top.
+ *
+ * Datapoint attributes (`disk_state`, `power_state`, `status`, `effective`,
+ * `direction`, `object`, `type`) are NOT filters here — they are per-query
+ * attribute filters on the metric query itself, exactly like the Kubernetes
+ * templates use them.
+ */
+export interface VMwareResourceFilters {
+  /** → `resource.vcenter.datacenter.name` equality. */
+  datacenterName?: string | undefined;
+  /**
+   * → `resource.vcenter.cluster.name` equality. Present on cluster, host,
+   * VM and resource-pool series when the object sits inside a cluster;
+   * absent for standalone ESXi hosts and the objects on them.
+   */
+  clusterName?: string | undefined;
+  /**
+   * → `resource.vcenter.host.name` equality. Scopes to the ESXi host's own
+   * series AND to the series of every VM it runs (the receiver stamps the
+   * parent host on VM resources), so a host filter alone still fans out
+   * across the VMs of that host — combine with `vmName` to target one VM.
+   */
+  hostName?: string | undefined;
+  /** → `resource.vcenter.vm.name` equality. */
+  vmName?: string | undefined;
+  /** → `resource.vcenter.datastore.name` equality. */
+  datastoreName?: string | undefined;
+  /**
+   * → `resource.vcenter.resource_pool.inventory_path` equality. The
+   * inventory path (`/DC/host/Cluster/Resources/pool`) is used rather than
+   * the pool name because pool names are only unique within a parent.
+   */
+  resourcePoolPath?: string | undefined;
+}
+
+export default interface MonitorStepVMwareMonitor {
+  /**
+   * The `vmware.vcenter.name` resource attribute the agent stamps on every
+   * metric — one value per vCenter Server (or standalone ESXi host) the
+   * agent connects to.
+   */
+  vcenterIdentifier: string;
+  resourceFilters: VMwareResourceFilters;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepVMwareMonitorUtil {
+  public static getDefault(): MonitorStepVMwareMonitor {
+    return {
+      vcenterIdentifier: "",
+      resourceFilters: {},
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      /*
+       * The VMware Agent polls vCenter every VCENTER_COLLECTION_INTERVAL
+       * (2 minutes by default) and the vcenter receiver emits ONE sample per
+       * object per collection, so the 1-minute window the 30-second Proxmox
+       * and Kubernetes agents default to would hold no sample on roughly
+       * every other evaluation — a hand-built monitor would flip between
+       * "no criteria met" and firing every tick. Default to 5 minutes (at
+       * least two collections) so the step form, the metric picker, the API
+       * and Terraform all seed the same safe window; the shipped templates
+       * hard-code 5 / 15 minutes for the same reason.
+       */
+      rollingTime: RollingTime.Past5Minutes,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepVMwareMonitor {
+    return json as any as MonitorStepVMwareMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepVMwareMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorTemplateSyncField.ts

@@ -0,0 +1,291 @@
+import BadDataException from "../Exception/BadDataException";
+import MonitorType from "./MonitorType";
+
+export interface MonitorTemplateSyncField {
+  path: string;
+  label: string;
+  description?: string;
+}
+
+/**
+ * The shared catalogue for the template editor and sync service. Only these
+ * named fields can be preserved; criteria and step identities always sync.
+ * Some options preserve related values together to keep credentials and
+ * resource selectors consistent.
+ */
+export default class MonitorTemplateSyncFieldUtil {
+  public static getFields(
+    monitorType: MonitorType,
+  ): Array<MonitorTemplateSyncField> {
+    const fields: Array<MonitorTemplateSyncField> = [];
+    const add: (path: string, label: string, description?: string) => void = (
+      path: string,
+      label: string,
+      description?: string,
+    ): void => {
+      fields.push({ path, label, ...(description ? { description } : {}) });
+    };
+
+    if (
+      [
+        MonitorType.Website,
+        MonitorType.API,
+        MonitorType.Ping,
+        MonitorType.IP,
+        MonitorType.Port,
+        MonitorType.SSLCertificate,
+      ].includes(monitorType)
+    ) {
+      add("monitorDestination", "Monitor destination");
+      add("requestTimeoutInMs", "Request timeout");
+      add("retryCount", "Retry count");
+    }
+
+    if (monitorType === MonitorType.API) {
+      add(
+        "requestHeaders",
+        "Request headers",
+        "Keep the monitor's entire set of request headers.",
+      );
+      add("requestType", "Request method");
+      add("requestBody", "Request body");
+    }
+
+    if ([MonitorType.Website, MonitorType.API].includes(monitorType)) {
+      add("doNotFollowRedirects", "Redirect behavior");
+      add("allowSelfSignedCertificates", "Allow self-signed certificates");
+      add(
+        "tlsClientAuthentication",
+        "Client certificate authentication",
+        "Keep the certificate, private key, and key passphrase together.",
+      );
+    }
+
+    if (monitorType === MonitorType.Port) {
+      add("monitorDestinationPort", "Port");
+    }
+
+    if (
+      [MonitorType.SyntheticMonitor, MonitorType.CustomJavaScriptCode].includes(
+        monitorType,
+      )
+    ) {
+      add("customCode", "Check code");
+    }
+
+    if (monitorType === MonitorType.SyntheticMonitor) {
+      add("browserTypes", "Browsers");
+      add("screenSizeTypes", "Screen sizes");
+      add("retryCountOnError", "Retry count on error");
+    }
+
+    if (monitorType === MonitorType.DNS) {
+      add("dnsMonitor.queryName", "DNS query name");
+      add("dnsMonitor.recordType", "DNS record type");
+      add(
+        "dnsMonitor.resolver",
+        "DNS resolver",
+        "Keep the DNS server and port together.",
+      );
+      add("dnsMonitor.timeout", "DNS timeout");
+      add("dnsMonitor.retries", "DNS retries");
+    }
+
+    if (monitorType === MonitorType.Domain) {
+      add("domainMonitor.domainName", "Domain name");
+      add("domainMonitor.lookupMethod", "Domain lookup method");
+      add("domainMonitor.timeout", "Lookup timeout");
+      add("domainMonitor.retries", "Lookup retries");
+    }
+
+    if (monitorType === MonitorType.DNSSEC) {
+      add("dnssecMonitor.domainName", "Domain name");
+      add("dnssecMonitor.resolvers", "DNS resolvers");
+      add(
+        "dnssecMonitor.checkNameserverConsistency",
+        "Nameserver consistency check",
+      );
+      add(
+        "dnssecMonitor.signatureExpiryWarningDays",
+        "Signature expiry warning",
+      );
+      add("dnssecMonitor.timeout", "DNSSEC timeout");
+      add("dnssecMonitor.retries", "DNSSEC retries");
+    }
+
+    if ([MonitorType.SQLQuery, MonitorType.Database].includes(monitorType)) {
+      const prefix: string =
+        monitorType === MonitorType.SQLQuery ? "sqlMonitor" : "databaseMonitor";
+      add(
+        `${prefix}.connection`,
+        "Database connection",
+        "Keep the database engine, host, port, database name, credentials, and TLS settings together.",
+      );
+      add(`${prefix}.connectionTimeoutInMs`, "Connection timeout");
+      add(`${prefix}.statementTimeoutInMs`, "Statement timeout");
+      if (monitorType === MonitorType.SQLQuery) {
+        add("sqlMonitor.query", "SQL query");
+        add("sqlMonitor.maxRows", "Maximum result rows");
+      } else {
+        add("databaseMonitor.enabledMetricGroups", "Collected metric groups");
+      }
+    }
+
+    if (monitorType === MonitorType.ExternalStatusPage) {
+      add("externalStatusPageMonitor.statusPageUrl", "Status page URL");
+      add("externalStatusPageMonitor.provider", "Status page provider");
+      add(
+        "externalStatusPageMonitor.components",
+        "Status page components",
+        "Keep the selected component group and component together.",
+      );
+      add("externalStatusPageMonitor.timeout", "Status page timeout");
+      add("externalStatusPageMonitor.retries", "Status page retries");
+    }
+
+    const infrastructure: Partial<
+      Record<MonitorType, [string, string, string]>
+    > = {
+      [MonitorType.Kubernetes]: [
+        "kubernetesMonitor",
+        "clusterIdentifier",
+        "Kubernetes cluster",
+      ],
+      [MonitorType.Docker]: ["dockerMonitor", "hostIdentifier", "Docker host"],
+      [MonitorType.Host]: ["hostMonitor", "hostIdentifier", "Host"],
+      [MonitorType.Podman]: ["podmanMonitor", "hostIdentifier", "Podman host"],
+      [MonitorType.Proxmox]: [
+        "proxmoxMonitor",
+        "clusterIdentifier",
+        "Proxmox cluster",
+      ],
+      [MonitorType.DockerSwarm]: [
+        "dockerSwarmMonitor",
+        "clusterIdentifier",
+        "Docker Swarm cluster",
+      ],
+      [MonitorType.Ceph]: ["cephMonitor", "clusterIdentifier", "Ceph cluster"],
+      [MonitorType.IoTDevice]: ["iotMonitor", "fleetIdentifier", "IoT fleet"],
+    };
+    const infrastructureConfig: [string, string, string] | undefined =
+      infrastructure[monitorType];
+    if (infrastructureConfig) {
+      const [prefix, identity, label]: [string, string, string] =
+        infrastructureConfig;
+      add(`${prefix}.${identity}`, label);
+      if (monitorType === MonitorType.Kubernetes) {
+        add(`${prefix}.resources`, "Resource scope and filters");
+      } else if (
+        [MonitorType.Docker, MonitorType.Podman].includes(monitorType)
+      ) {
+        add(`${prefix}.containerFilters`, "Container filters");
+      } else if (monitorType !== MonitorType.Host) {
+        add(`${prefix}.resourceFilters`, "Resource filters");
+      }
+      add(`${prefix}.metricViewConfig`, "Metric queries");
+      add(`${prefix}.rollingTime`, "Query time window");
+    }
+
+    const telemetry: Partial<Record<MonitorType, [string, string]>> = {
+      [MonitorType.Logs]: ["logMonitor", "Log query configuration"],
+      [MonitorType.SecurityEvents]: [
+        "securityEventsMonitor",
+        "Security event query configuration",
+      ],
+      [MonitorType.Traces]: ["traceMonitor", "Trace query configuration"],
+      [MonitorType.Metrics]: ["metricMonitor", "Metric query configuration"],
+      [MonitorType.Exceptions]: [
+        "exceptionMonitor",
+        "Exception query configuration",
+      ],
+      [MonitorType.Profiles]: ["profileMonitor", "Profile query configuration"],
+    };
+    const telemetryConfig: [string, string] | undefined =
+      telemetry[monitorType];
+    if (telemetryConfig) {
+      add(...telemetryConfig);
+    }
+
+    return fields;
+  }
+
+  public static parse(
+    value: unknown,
+    monitorType?: MonitorType,
+  ): Array<string> | undefined {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    if (
+      !Array.isArray(value) ||
+      value.some((path: unknown): boolean => {
+        return typeof path !== "string";
+      })
+    ) {
+      throw new BadDataException(
+        "Do not sync fields must be an array of supported field names.",
+      );
+    }
+
+    const allowedFields: Set<string> = new Set(
+      (monitorType === undefined ? Object.values(MonitorType) : [monitorType])
+        .flatMap((type: MonitorType): Array<MonitorTemplateSyncField> => {
+          return this.getFields(type);
+        })
+        .map((field: MonitorTemplateSyncField): string => {
+          return field.path;
+        }),
+    );
+
+    for (const path of value) {
+      if (!allowedFields.has(path)) {
+        throw new BadDataException(`Unsupported do not sync field: ${path}.`);
+      }
+    }
+
+    return [...new Set(value as Array<string>)];
+  }
+
+  public static getPaths(field: string): Array<string> {
+    // Validate even when called independently of parse: never traverse arbitrary paths.
+    this.parse([field]);
+    if (field === "tlsClientAuthentication") {
+      return ["tlsClientCertificate", "tlsClientKey", "tlsClientKeyPassphrase"];
+    }
+    if (field === "dnsMonitor.resolver") {
+      return ["dnsMonitor.hostname", "dnsMonitor.port"];
+    }
+    if (
+      ["sqlMonitor.connection", "databaseMonitor.connection"].includes(field)
+    ) {
+      const prefix: string = field.split(".")[0]!;
+      return [
+        "databaseType",
+        "host",
+        "port",
+        "databaseName",
+        "username",
+        "password",
+        "useWindowsIntegratedAuthentication",
+        "useSsl",
+        "rejectUnauthorizedSsl",
+      ].map((key: string): string => {
+        return `${prefix}.${key}`;
+      });
+    }
+    if (field === "externalStatusPageMonitor.components") {
+      return [
+        "externalStatusPageMonitor.componentGroupName",
+        "externalStatusPageMonitor.componentName",
+      ];
+    }
+    if (field === "kubernetesMonitor.resources") {
+      return [
+        "kubernetesMonitor.resourceScope",
+        "kubernetesMonitor.resourceFilters",
+      ];
+    }
+    return [field];
+  }
+}