@oneuptime/common 12.0.34 → 13.0.1

package/Server/Services/MonitorTemplateService.ts

@@ -16,13 +16,16 @@ import Includes from "../../Types/BaseDatabase/Includes";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import { JSONObject } from "../../Types/JSON";
 import MonitorSteps from "../../Types/Monitor/MonitorSteps";
+import MonitorTemplateSyncFieldUtil from "../../Types/Monitor/MonitorTemplateSyncField";
 import MonitorType from "../../Types/Monitor/MonitorType";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "../../Models/DatabaseModels/MonitorTemplate";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import MonitorTemplateCustomFieldUtil from "../../Utils/Monitor/MonitorTemplateCustomFieldUtil";
 import NetworkDeviceMonitorTemplateUtil from "../../Utils/Monitor/NetworkDeviceMonitorTemplateUtil";
+import MonitorTemplateSyncUtil from "../../Utils/Monitor/MonitorTemplateSyncUtil";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import ModelPermission from "../Types/Database/Permissions/Index";
 import Query from "../Types/Database/Query";
@@ -41,9 +44,31 @@ export type SyncableTemplateField =
   | "monitorSteps"
   | "monitoringInterval"
   | "minimumProbeAgreement"
-  | "labels";
+  | "labels"
+  | "customFields";
 
-const ALL_SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
+const SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
+  "monitorSteps",
+  "monitoringInterval",
+  "minimumProbeAgreement",
+  "labels",
+  "customFields",
+];
+
+/*
+ * What an UNSCOPED sync pushes — every syncable field except custom field
+ * defaults.
+ *
+ * Custom fields are the one syncable thing whose per-monitor value is
+ * ordinarily typed in by hand: a monitor's Configuration Item or Vendor is
+ * about that device, not about the template. A caller that names no fields is
+ * saying "push the template", not "and also rewrite every operator-entered
+ * value in the fleet", so custom fields ship only when asked for by name —
+ * which is what the dedicated button on the template's Custom Field Defaults
+ * card does. The dashboard always scopes its syncs, so this only decides what
+ * an API caller gets by default.
+ */
+const DEFAULT_SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
   "monitorSteps",
   "monitoringInterval",
   "minimumProbeAgreement",
@@ -55,6 +80,29 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  private validateSyncFields(
+    steps: MonitorSteps | JSONObject | undefined,
+    monitorType: MonitorType | undefined,
+  ): void {
+    if (!steps) {
+      return;
+    }
+
+    for (const step of MonitorSteps.fromJSON(steps).data
+      ?.monitorStepsInstanceArray || []) {
+      const fields: Array<string> | undefined =
+        MonitorTemplateSyncFieldUtil.parse(
+          step.data?.doNotSyncFields,
+          monitorType,
+        );
+      if (fields?.length && !monitorType) {
+        throw new BadDataException(
+          "Monitor type is required to configure template sync fields",
+        );
+      }
+    }
+  }
+
   /*
    * A template's monitorSteps embeds the same reference ids a monitor's does,
    * and every one of them reaches a real monitor eventually — through "create
@@ -68,6 +116,10 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
+    this.validateSyncFields(
+      createBy.data.monitorSteps,
+      createBy.data.monitorType,
+    );
     await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
       monitorSteps: createBy.data.monitorSteps,
       projectId: createBy.props.tenantId || createBy.data.projectId,
@@ -80,7 +132,7 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
-    if (!updateBy.data.monitorSteps) {
+    if (!updateBy.data.monitorSteps && !updateBy.data.monitorType) {
       return { updateBy, carryForward: null };
     }
 
@@ -94,6 +146,7 @@ export class Service extends DatabaseService<Model> {
       select: {
         projectId: true,
         monitorSteps: true,
+        monitorType: true,
       },
       limit: LIMIT_MAX,
       skip: 0,
@@ -104,6 +157,16 @@ export class Service extends DatabaseService<Model> {
     });
 
     for (const template of templates) {
+      this.validateSyncFields(
+        updateBy.data.monitorSteps === undefined
+          ? template.monitorSteps
+          : (updateBy.data.monitorSteps as MonitorSteps | JSONObject),
+        (updateBy.data.monitorType as MonitorType | undefined) ||
+          template.monitorType,
+      );
+      if (!updateBy.data.monitorSteps) {
+        continue;
+      }
       await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
         monitorSteps: updateBy.data.monitorSteps as MonitorSteps | JSONObject,
         projectId: updateBy.props.tenantId || template.projectId,
@@ -309,10 +372,10 @@ export class Service extends DatabaseService<Model> {
     fields: Array<string> | undefined,
   ): Array<SyncableTemplateField> {
     if (!fields || fields.length === 0) {
-      return [...ALL_SYNCABLE_FIELDS];
+      return [...DEFAULT_SYNCABLE_FIELDS];
     }
 
-    const allowed: Set<string> = new Set(ALL_SYNCABLE_FIELDS);
+    const allowed: Set<string> = new Set(SYNCABLE_FIELDS);
     for (const field of fields) {
       if (!allowed.has(field)) {
         throw new BadDataException(
@@ -323,6 +386,16 @@ export class Service extends DatabaseService<Model> {
     return fields as Array<SyncableTemplateField>;
   }
 
+  /*
+   * The part of the push that is identical for every linked monitor, so it can
+   * ride a single bulk update.
+   *
+   * `customFields` is deliberately absent: a template's custom fields are
+   * DEFAULTS overlaid on whatever the monitor already holds, which is a
+   * different value per monitor and therefore cannot be one shared payload.
+   * The two sync entry points below compute it per monitor instead — see
+   * buildCustomFieldsUpdate.
+   */
   private buildUpdateData(
     template: Model,
     fields: Array<SyncableTemplateField>,
@@ -330,6 +403,10 @@ export class Service extends DatabaseService<Model> {
     const updateData: Partial<Monitor> = {};
 
     for (const field of fields) {
+      if (field === "customFields") {
+        continue;
+      }
+
       const value: unknown = (template as unknown as Record<string, unknown>)[
         field
       ];
@@ -342,13 +419,85 @@ export class Service extends DatabaseService<Model> {
     return updateData;
   }
 
+  /*
+   * Does this push carry custom field defaults that are worth a write?
+   *
+   * A template whose bag is absent, empty, or holds nothing but blanks has no
+   * defaults to give, and saying so here is what stops a custom-fields-only
+   * sync from taking the per-monitor path (and reporting a fleet-wide write)
+   * to push nothing at all.
+   */
+  private hasCustomFieldDefaultsToSync(
+    template: Model,
+    fields: Array<SyncableTemplateField>,
+  ): boolean {
+    return (
+      fields.includes("customFields") &&
+      MonitorTemplateCustomFieldUtil.hasDefaults(template.customFields)
+    );
+  }
+
+  /*
+   * One monitor's custom field bag after the template's defaults are laid over
+   * it: the template wins every field it actually defaults, and every other
+   * value the operator entered on that monitor survives untouched.
+   */
+  private buildCustomFieldsUpdate(data: {
+    template: Model;
+    monitor: Monitor;
+  }): JSONObject {
+    return MonitorTemplateCustomFieldUtil.applyDefaults({
+      templateCustomFields: data.template.customFields,
+      monitorCustomFields: data.monitor.customFields,
+    });
+  }
+
+  /** Merge protected fields before applying the device ownership binding. */
+  private buildMonitorStepsUpdate(
+    template: Model,
+    monitor: Monitor,
+  ): MonitorSteps {
+    let monitorSteps: MonitorSteps | undefined = template.monitorSteps;
+
+    if (MonitorTemplateSyncUtil.hasExcludedFields(monitorSteps)) {
+      if (!template.monitorType) {
+        throw new BadDataException("Monitor template is missing monitorType");
+      }
+      monitorSteps = MonitorTemplateSyncUtil.buildSyncedMonitorSteps({
+        templateMonitorSteps: monitorSteps,
+        currentMonitorSteps: monitor.monitorSteps,
+        monitorType: template.monitorType,
+      });
+    }
+
+    if (template.monitorType === MonitorType.NetworkDevice) {
+      monitorSteps = monitor.autoProvisionedNetworkDeviceId
+        ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
+            monitorSteps,
+            networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
+          })
+        : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
+            templateMonitorSteps: monitorSteps,
+            currentMonitorSteps: monitor.monitorSteps,
+          });
+    }
+
+    if (!monitorSteps) {
+      throw new BadDataException(
+        "Monitor template steps are required to sync criteria.",
+      );
+    }
+
+    return monitorSteps;
+  }
+
   /**
    * Push the template's current configuration onto every monitor that was
    * created from it. Sync is intentionally explicit (button-triggered) so a
    * config tweak doesn't silently re-deploy across the whole fleet.
    *
    * Pass `fields` to scope the sync — e.g. `["monitorSteps"]` to push only the
-   * criteria. If omitted, every syncable field is pushed.
+   * criteria. If omitted, DEFAULT_SYNCABLE_FIELDS is pushed.
    */
   @CaptureSpan()
   public async syncLinkedMonitors(data: {
@@ -369,6 +518,7 @@ export class Service extends DatabaseService<Model> {
         monitorSteps: true,
         monitoringInterval: true,
         minimumProbeAgreement: true,
+        customFields: true,
         labels: {
           _id: true,
         },
@@ -398,7 +548,17 @@ export class Service extends DatabaseService<Model> {
 
     const updateData: Partial<Monitor> = this.buildUpdateData(template, fields);
 
-    if (Object.keys(updateData).length === 0) {
+    /*
+     * Custom field defaults never ride in updateData — the value written
+     * depends on what each monitor already holds — so they are their own
+     * reason for this push to have work to do.
+     */
+    const syncCustomFields: boolean = this.hasCustomFieldDefaultsToSync(
+      template,
+      fields,
+    );
+
+    if (Object.keys(updateData).length === 0 && !syncCustomFields) {
       return {
         totalLinkedMonitors,
         syncedMonitors: 0,
@@ -410,12 +570,20 @@ export class Service extends DatabaseService<Model> {
      * while each linked monitor has its own device. A bulk JSON assignment
      * would retarget the entire fleet to the template editor's device. Sync
      * those rows individually and rebind cloned template steps to each
-     * monitor's current (or provenance-backed) device instead.
+     * monitor's current (or provenance-backed) device instead. Field exclusions
+     * also require one merge per monitor so each keeps its own protected values.
      */
-    if (
-      template.monitorType === MonitorType.NetworkDevice &&
-      fields.includes("monitorSteps")
-    ) {
+    const mergeMonitorSteps: boolean =
+      fields.includes("monitorSteps") &&
+      (template.monitorType === MonitorType.NetworkDevice ||
+        MonitorTemplateSyncUtil.hasExcludedFields(template.monitorSteps));
+
+    /*
+     * Custom field defaults take the same row-at-a-time path for their own
+     * reason: they are overlaid on the monitor's existing bag, so the payload
+     * is read from the row being written and cannot be shared.
+     */
+    if (mergeMonitorSteps || syncCustomFields) {
       let syncedMonitors: number = 0;
       const linkedMonitorQuery: Query<Monitor> = {
         monitorTemplateId: template.id!,
@@ -428,12 +596,20 @@ export class Service extends DatabaseService<Model> {
        * label scope order-dependent: accessible rows could update before a
        * later hidden row threw. This is the same permission-narrowed subset
        * the ordinary bulk update path applies atomically.
+       *
+       * The probe names `customFields` when this push writes them — the
+       * per-monitor values are not known yet, and only the KEYS decide the
+       * column check — so a caller who may not update that column is refused
+       * up front rather than on an arbitrary row partway through the fleet.
        */
       const authorizedMonitorQuery: Query<Monitor> =
         await ModelPermission.checkUpdateQueryPermissions(
           Monitor,
           linkedMonitorQuery,
-          updateData as any,
+          {
+            ...updateData,
+            ...(syncCustomFields ? { customFields: {} } : {}),
+          } as any,
           data.props,
         );
       const monitorsToSync: Array<Monitor> = [];
@@ -444,6 +620,7 @@ export class Service extends DatabaseService<Model> {
           select: {
             _id: true,
             monitorSteps: true,
+            customFields: true,
             autoProvisionedNetworkDeviceId: true,
           },
           sort: { createdAt: SortOrder.Ascending, _id: SortOrder.Ascending },
@@ -468,15 +645,19 @@ export class Service extends DatabaseService<Model> {
           monitor,
           data: {
             ...updateData,
-            monitorSteps: monitor.autoProvisionedNetworkDeviceId
-              ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
-                  monitorSteps: template.monitorSteps,
-                  networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
-                })
-              : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
-                  templateMonitorSteps: template.monitorSteps,
-                  currentMonitorSteps: monitor.monitorSteps,
-                }),
+            ...(mergeMonitorSteps
+              ? {
+                  monitorSteps: this.buildMonitorStepsUpdate(template, monitor),
+                }
+              : {}),
+            ...(syncCustomFields
+              ? {
+                  customFields: this.buildCustomFieldsUpdate({
+                    template,
+                    monitor,
+                  }),
+                }
+              : {}),
           },
         };
       });
@@ -642,6 +823,7 @@ export class Service extends DatabaseService<Model> {
         monitorSteps: true,
         monitoringInterval: true,
         minimumProbeAgreement: true,
+        customFields: true,
         labels: {
           _id: true,
         },
@@ -664,6 +846,7 @@ export class Service extends DatabaseService<Model> {
         projectId: true,
         monitorTemplateId: true,
         monitorSteps: true,
+        customFields: true,
         autoProvisionedNetworkDeviceId: true,
       },
       props: { isRoot: true },
@@ -691,19 +874,19 @@ export class Service extends DatabaseService<Model> {
 
     const updateData: Partial<Monitor> = this.buildUpdateData(template, fields);
 
-    if (
-      template.monitorType === MonitorType.NetworkDevice &&
-      fields.includes("monitorSteps")
-    ) {
-      updateData.monitorSteps = monitor.autoProvisionedNetworkDeviceId
-        ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
-            monitorSteps: template.monitorSteps,
-            networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
-          })
-        : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
-            templateMonitorSteps: template.monitorSteps,
-            currentMonitorSteps: monitor.monitorSteps,
-          });
+    if (updateData.monitorSteps !== undefined) {
+      updateData.monitorSteps = this.buildMonitorStepsUpdate(template, monitor);
+    }
+
+    /*
+     * Overlaid on this monitor's own bag, so a value the operator entered on
+     * a field the template does not default survives the push.
+     */
+    if (this.hasCustomFieldDefaultsToSync(template, fields)) {
+      updateData.customFields = this.buildCustomFieldsUpdate({
+        template,
+        monitor,
+      });
     }
 
     if (Object.keys(updateData).length === 0) {