@oneuptime/common 12.0.33 → 13.0.0

package/Server/Services/NetworkDeviceDiscoveryScanService.ts

@@ -1,6 +1,8 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import Model, {
+  DiscoveredNetworkDevice,
+} from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { OnCreate, OnFind, OnUpdate } from "../Types/Database/Hooks";
 import CreateBy from "../Types/Database/CreateBy";
 import UpdateBy from "../Types/Database/UpdateBy";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -20,6 +22,7 @@ import SnmpScanConfigUtil, {
 } from "../../Utils/NetworkDiscovery/SnmpScanConfigUtil";
 import { getNextScanAt } from "../../Utils/NetworkDiscovery/RescanIntervalUtil";
 import ScanModeUtil from "../../Utils/NetworkDiscovery/ScanModeUtil";
+import NetworkDeviceService from "./NetworkDeviceService";
 
 /*
  * The two spellings a many-to-one reference reaches a hook under: the
@@ -175,6 +178,88 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  @CaptureSpan()
+  protected override async onFindSuccess(
+    onFind: OnFind<Model>,
+    items: Array<Model>,
+  ): Promise<OnFind<Model>> {
+    /*
+     * Registration is current inventory state, not a fact about the scan.
+     * Refresh both directions so old results can be used after a deletion.
+     */
+    const hostnamesByProject: Map<string, Set<string>> = new Map();
+
+    for (const scan of items) {
+      const projectId: ObjectID | undefined =
+        scan.projectId || onFind.findBy.props.tenantId;
+
+      if (!projectId || !Array.isArray(scan.discoveredDevices)) {
+        continue;
+      }
+
+      for (const host of scan.discoveredDevices) {
+        const hostname: string = this.getDiscoveredHostname(host);
+        if (!hostname) {
+          continue;
+        }
+
+        const projectKey: string = projectId.toString();
+        if (!hostnamesByProject.has(projectKey)) {
+          hostnamesByProject.set(projectKey, new Set());
+        }
+        hostnamesByProject.get(projectKey)!.add(hostname);
+      }
+    }
+
+    const registeredByProject: Map<string, Set<string>> = new Map();
+    for (const [projectId, hostnames] of hostnamesByProject) {
+      registeredByProject.set(
+        projectId,
+        await NetworkDeviceService.getRegisteredHostnames({
+          projectId: new ObjectID(projectId),
+          hostnames: Array.from(hostnames),
+          /*
+           * The scan read has already passed its access checks. Return only
+           * the same existence flag as probe ingest, scoped to this project.
+           */
+          props: { isRoot: true },
+        }),
+      );
+    }
+
+    return {
+      ...onFind,
+      carryForward: items.map((scan: Model): Model => {
+        const projectId: ObjectID | undefined =
+          scan.projectId || onFind.findBy.props.tenantId;
+        const registered: Set<string> | undefined = projectId
+          ? registeredByProject.get(projectId.toString())
+          : undefined;
+
+        if (!registered || !Array.isArray(scan.discoveredDevices)) {
+          return scan;
+        }
+
+        return Object.assign(new Model(), scan, {
+          discoveredDevices: scan.discoveredDevices.map(
+            (host: DiscoveredNetworkDevice): DiscoveredNetworkDevice => {
+              const hostname: string = this.getDiscoveredHostname(host);
+              return hostname
+                ? { ...host, isAlreadyRegistered: registered.has(hostname) }
+                : host;
+            },
+          ),
+        });
+      }),
+    };
+  }
+
+  private getDiscoveredHostname(host: DiscoveredNetworkDevice): string {
+    return host && typeof host.ipAddress === "string"
+      ? host.ipAddress.trim()
+      : "";
+  }
+
   /*
    * Validate the scan target at write time, with the same parser the probe
    * expands it with (Common/Utils/NetworkDiscovery/ScanTargetUtil).

package/Server/Services/NetworkDeviceService.ts

@@ -30,6 +30,7 @@ import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import CidrMatchUtil from "../../Utils/NetworkSite/CidrMatchUtil";
+import { normalizeMac } from "../../Utils/Monitor/EndpointAttachmentUtil";
 import { SiteAssignmentRuleRunResult } from "../../Types/NetworkAutomation/RuleRunResult";
 import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 import RelationIdUtil from "../Utils/Database/RelationIdUtil";
@@ -96,6 +97,61 @@ const SITE_KEYS: Array<string> = ["siteId", "site"];
  * otherwise a no-op rewrite of sysName on every SNMP walk would look like a
  * change and re-run the rules for the whole fleet every polling cycle.
  */
+/*
+ * The MAC address column, normalised on the way in.
+ *
+ * Every spelling an operator is likely to paste - AA-BB-CC-DD-EE-FF,
+ * aabb.ccdd.eeff, aa:bb:cc:dd:ee:ff, twelve bare hex digits, with or
+ * without 0x - is stored as lowercase colon form, because that is the form
+ * every endpoint row already holds and the topology builder compares the
+ * two as plain strings. Anything that is not twelve hex digits once the
+ * separators are gone is refused outright rather than stored to match
+ * nothing forever. Blank clears the column, so "delete what I typed"
+ * works from a form that cannot post null.
+ *
+ * Shared by create and update, so it takes the raw payload: a create's
+ * data is a model instance and an update's is a QueryDeepPartialEntity, and
+ * on the latter a column may hold a SQL-expression function, which is left
+ * alone - nothing in the tree writes this column that way, and refusing it
+ * would only make a future caller's life harder for no safety gained.
+ *
+ * Every value that lands this way is the operator's, so the provenance flag
+ * is cleared beside it: the ARP pass writes hook-free and never comes
+ * through here, and it may only correct a value it wrote itself.
+ */
+function normalizeMacAddressOnWrite(data: Record<string, unknown>): void {
+  if (!("macAddress" in data)) {
+    return;
+  }
+
+  const raw: unknown = data["macAddress"];
+
+  // TypeORM drops undefined before it builds the SET list; null clears.
+  if (raw === undefined || raw === null || typeof raw === "function") {
+    return;
+  }
+
+  if (typeof raw !== "string") {
+    throw new BadDataException("MAC Address must be text.");
+  }
+
+  if (raw.trim().length === 0) {
+    data["macAddress"] = null;
+    data["isMacAddressLearned"] = false;
+    return;
+  }
+
+  const normalized: string | undefined = normalizeMac(raw);
+  if (!normalized) {
+    throw new BadDataException(
+      "MAC Address must be six pairs of hex digits, for example aa:bb:cc:dd:ee:ff. Dashes, dots and bare hex are accepted too.",
+    );
+  }
+
+  data["macAddress"] = normalized;
+  data["isMacAddressLearned"] = false;
+}
+
 function normalizeIdentityValue(value: unknown): string {
   if (value === null || value === undefined) {
     return "";
@@ -1239,6 +1295,10 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
+    normalizeMacAddressOnWrite(
+      createBy.data as unknown as Record<string, unknown>,
+    );
+
     /*
      * Read both spellings: the dashboard posts the `site` relation, not the
      * `siteId` column, so guarding only `siteId` let a UI-created device
@@ -1523,6 +1583,15 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnUpdate<Model>> {
     const dataKeys: Array<string> = Object.keys(updateBy.data || {});
 
+    /*
+     * Above the early return, like the id guards below it: a malformed
+     * MAC is refused on every write shape, not only on the ones that
+     * happen to need the snapshot.
+     */
+    normalizeMacAddressOnWrite(
+      updateBy.data as unknown as Record<string, unknown>,
+    );
+
     /*
      * Switching a device to monitor-backed turns polling off with it. The
      * two are one decision, not two: a monitor-backed device's health is

package/Server/Services/ProjectService.ts

@@ -1653,6 +1653,28 @@ These are no longer recorded against the project and have to be cancelled by han
     return createdItem;
   }
 
+  /*
+   * NOTE ON THE TWO-TIER SCALE, and what it costs downstream.
+   *
+   * This seeds TWO alert severities (High 1 / Low 2) while
+   * `addDefaultIncidentSeverity` immediately below seeds THREE
+   * (Critical Incident 1 / Major Incident 2 / Minor Incident 3). That
+   * asymmetry is load-bearing for monitor recommendations:
+   * `MonitorRecommendationSeverityMapper` maps a recommendation's declared
+   * `Critical` onto rank 1 and `Warning` onto rank 2, so on a default project
+   * a Warning template opens a "Major Incident" but an alert whose severity
+   * reads "Low" — which is how an alert email can say SEVERITY: Low for a
+   * catalog card badged Warning.
+   *
+   * If a third alert tier is ever added here to close that gap, it CANNOT
+   * ship alone. This function only seeds names a project does not already
+   * have, so existing projects would keep the two-tier scale and map Warning
+   * differently from new ones indefinitely. It needs a paired data migration
+   * over every existing project — see
+   * App/FeatureSet/Workers/DataMigrations/AddDefaultAlertSeverityAndStateToExistingProjects.ts
+   * for the shape — and that migration has to decide what to do about the
+   * `order` of a "Low" row a project may have reordered or renamed itself.
+   */
   @CaptureSpan()
   public async addDefaultAlertSeverity(createdItem: Model): Promise<Model> {
     const projectId: ObjectID = createdItem.id!;

package/Server/Services/RoutineEmailSettingsService.ts

@@ -0,0 +1,73 @@
+import DatabaseService, { EntityManager } from "./DatabaseService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
+import { ROUTINE_EMAIL_EVENT_TYPES } from "../../Types/NotificationSetting/RoutineEmailEvents";
+import ObjectID from "../../Types/ObjectID";
+
+export class Service extends DatabaseService<UserNotificationSetting> {
+  public constructor() {
+    super(UserNotificationSetting);
+  }
+
+  /*
+   * The API authorizes the authenticated user's own settings before calling
+   * this method. Every statement remains scoped to that user and project.
+   */
+  @CaptureSpan()
+  public async reduceRoutineEmails(data: {
+    userId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<void> {
+    await this.executeTransaction(async (manager: EntityManager) => {
+      /*
+       * There is no unique constraint on (user, project, event). Serializing
+       * preset requests also protects the missing-row insert on a double click.
+       */
+      await manager.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($1, 0))",
+        [
+          `routine-email-settings:${data.projectId.toString()}:${data.userId.toString()}`,
+        ],
+      );
+
+      const parameters: [string, string, ReadonlyArray<string>] = [
+        data.userId.toString(),
+        data.projectId.toString(),
+        ROUTINE_EMAIL_EVENT_TYPES,
+      ];
+
+      /*
+       * Update every matching row, including historical duplicates. Changing
+       * only email avoids overwriting another channel edited concurrently.
+       */
+      await manager.query(
+        `UPDATE "UserNotificationSetting"
+         SET "alertByEmail" = false, "updatedAt" = now(), "version" = "version" + 1
+         WHERE "userId" = $1 AND "projectId" = $2
+           AND "eventType" = ANY($3::text[])
+           AND "deletedAt" IS NULL AND "alertByEmail" = true`,
+        parameters,
+      );
+
+      /*
+       * Persist an explicit opt-out for missing events so later default
+       * seeding sees the user's choice. Other channels keep their false defaults.
+       */
+      await manager.query(
+        `INSERT INTO "UserNotificationSetting"
+           ("userId", "projectId", "eventType", "alertByEmail", "createdByUserId", "version")
+         SELECT $1::uuid, $2::uuid, event."eventType", false, $1::uuid, 1
+         FROM unnest($3::text[]) AS event("eventType")
+         WHERE NOT EXISTS (
+           SELECT 1 FROM "UserNotificationSetting" setting
+           WHERE setting."userId" = $1 AND setting."projectId" = $2
+             AND setting."eventType" = event."eventType"
+             AND setting."deletedAt" IS NULL
+         )`,
+        parameters,
+      );
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/RumSessionReplayViewService.ts

@@ -1,5 +1,6 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/RumSessionReplayView";
+import QueryHelper from "../Types/Database/QueryHelper";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import ObjectID from "../../Types/ObjectID";
@@ -19,6 +20,45 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
  * modelled on, the whole point of the audit is that it outlives the
  * recording it describes.
  */
+
+/*
+ * The heartbeat cadence the player reports on. secondsWatched is floored
+ * to it so a chatty client costs at most one write per bucket, and the
+ * figure shown to viewers ("watched 1m 30s") never pretends to more
+ * precision than the heartbeat had.
+ */
+export const SESSION_REPLAY_WATCH_BUCKET_SECONDS: number = 15;
+
+/*
+ * Ceiling on one view's watched time: the longest session the recorder
+ * will ever produce, at the slowest speed anyone would watch it, with
+ * headroom for pauses. A client cannot report more than this; the audit
+ * figure is a privacy control shown to other viewers, and an unbounded
+ * number would let a buggy or hostile client render a nonsense one.
+ */
+export const SESSION_REPLAY_MAX_SECONDS_WATCHED: number = 24 * 60 * 60;
+
+/*
+ * Floor a client-reported figure to the heartbeat bucket and clamp it.
+ * Module-level so the route and the service agree on the one rounding
+ * rule without the route reaching for the class behind the instance.
+ */
+export function normalizeSecondsWatched(secondsWatched: number): number {
+  if (!Number.isFinite(secondsWatched) || secondsWatched <= 0) {
+    return 0;
+  }
+
+  const clamped: number = Math.min(
+    secondsWatched,
+    SESSION_REPLAY_MAX_SECONDS_WATCHED,
+  );
+
+  return (
+    Math.floor(clamped / SESSION_REPLAY_WATCH_BUCKET_SECONDS) *
+    SESSION_REPLAY_WATCH_BUCKET_SECONDS
+  );
+}
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -64,12 +104,13 @@ export class Service extends DatabaseService<Model> {
     }
 
     /*
-     * All three come straight off an untrusted request: a header, or a
+     * All four come straight off an untrusted request: a header, or a
      * free-text field in the body. Truncated rather than validated because
      * failing the audit write would fail the playback it is auditing, and
      * DatabaseService.checkMaxLengthOfFields throws on anything longer
-     * than the column. An oversized user agent must not be able to stop a
-     * read from being recorded.
+     * than the column. An oversized user agent - or a fingerprint longer
+     * than its ShortText column - must not be able to stop a read from
+     * being recorded.
      */
     if (data.ipAddress) {
       item.ipAddress = data.ipAddress.substring(0, ColumnLength.ShortText);
@@ -88,7 +129,8 @@ export class Service extends DatabaseService<Model> {
     }
 
     if (data.linkedExceptionFingerprint) {
-      item.linkedExceptionFingerprint = data.linkedExceptionFingerprint;
+      item.linkedExceptionFingerprint =
+        data.linkedExceptionFingerprint.substring(0, ColumnLength.ShortText);
     }
 
     return await this.create({
@@ -98,47 +140,85 @@ export class Service extends DatabaseService<Model> {
   }
 
   /*
-   * Advance how much of the recording was actually watched, from the
-   * player's throttled heartbeat.
-   *
-   * Monotonic on purpose: the heartbeat carries a cumulative total, and a
-   * player that seeks backwards or reloads would otherwise walk the
-   * recorded figure back down and make a full viewing look like a glance.
+   * The caller's OWN view row, or null. The heartbeat and the manifest
+   * refresh both need "does this viewId belong to this user, this
+   * project, and (for the refresh) this session" answered in one lookup,
+   * and both must refuse somebody else's row indistinguishably from a
+   * missing one: secondsWatched is a privacy control, and the refresh
+   * would otherwise let a caller reuse a colleague's audit row.
    */
   @CaptureSpan()
-  public async recordSecondsWatched(data: {
+  public async findOwnView(data: {
     viewId: ObjectID;
     projectId: ObjectID;
-    secondsWatched: number;
-  }): Promise<void> {
-    if (!Number.isFinite(data.secondsWatched) || data.secondsWatched <= 0) {
-      return;
-    }
-
-    const existing: Model | null = await this.findOneBy({
+    viewedByUserId: ObjectID;
+    sessionId?: string | undefined;
+  }): Promise<Model | null> {
+    return await this.findOneBy({
       query: {
         _id: data.viewId.toString(),
         projectId: data.projectId,
+        viewedByUserId: data.viewedByUserId,
+        ...(data.sessionId !== undefined && { sessionId: data.sessionId }),
       },
       select: {
         _id: true,
+        rumApplicationId: true,
+        sessionId: true,
         secondsWatched: true,
       },
       props: { isRoot: true },
     });
+  }
+
+  /*
+   * Advance how much of the recording was actually watched.
+   *
+   * SEMANTICS: secondsWatched is the cumulative number of seconds of
+   * footage the player has PLAYED for this view - accumulated client-side
+   * only while playback is running, scaled by speed - not the furthest
+   * offset the playhead reached. Dragging the scrubber to the end of a
+   * recording is not watching it, and the audit figure is shown to other
+   * viewers as "who watched how much", so it must not over-report.
+   *
+   * Monotonic on purpose: the heartbeat carries a cumulative total, and a
+   * player that reloads would otherwise walk the recorded figure back
+   * down and make a full viewing look like a glance. The guard is in the
+   * UPDATE's own predicate (secondsWatched < new value) rather than in a
+   * read-then-write, so two heartbeats racing for the same row cannot
+   * regress it; a heartbeat that does not advance writes nothing.
+   *
+   * When the caller already holds the row's current figure (the route
+   * reads it in the same lookup that proves ownership) it passes it as
+   * currentSecondsWatched and a non-advancing heartbeat costs no query at
+   * all.
+   */
+  @CaptureSpan()
+  public async recordSecondsWatched(data: {
+    viewId: ObjectID;
+    projectId: ObjectID;
+    secondsWatched: number;
+    currentSecondsWatched?: number | undefined;
+  }): Promise<void> {
+    const seconds: number = normalizeSecondsWatched(data.secondsWatched);
 
-    if (!existing) {
+    if (seconds <= 0) {
       return;
     }
 
-    const seconds: number = Math.floor(data.secondsWatched);
-
-    if ((existing.secondsWatched || 0) >= seconds) {
+    if (
+      data.currentSecondsWatched !== undefined &&
+      data.currentSecondsWatched >= seconds
+    ) {
       return;
     }
 
-    await this.updateOneById({
-      id: data.viewId,
+    await this.updateOneBy({
+      query: {
+        _id: data.viewId.toString(),
+        projectId: data.projectId,
+        secondsWatched: QueryHelper.lessThanOrNull(seconds),
+      },
       data: {
         secondsWatched: seconds,
       },

package/Server/Services/ScheduledMaintenanceCustomFieldService.ts

@@ -1,9 +1,107 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/ScheduledMaintenanceCustomField";
+import ObjectID from "../../Types/ObjectID";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { backfillMappedCustomFieldValues } from "../Utils/CustomField/CustomFieldDefinitionMappingHooks";
+import {
+  validateCustomFieldMappingOnCreate,
+  validateCustomFieldMappingOnUpdate,
+} from "../Utils/CustomField/CustomFieldMappingValidator";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
+/*
+ * A scheduled maintenance custom field can take its value from the same field
+ * on the event's monitors instead of being typed in again
+ * (OneUptime/oneuptime#3549). These hooks are the two halves of that
+ * configuration being saved: refusing a mapping that could never resolve, and
+ * filling in the events that already exist once one is saved.
+ */
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    await validateCustomFieldMappingOnCreate({
+      definitionModelType: Model,
+      createBy: createBy,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    await validateCustomFieldMappingOnUpdate({
+      definitionModelType: Model,
+      definitionService: this,
+      updateBy: updateBy,
+    });
+
+    return { updateBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    backfillMappedCustomFieldValues({
+      definitionModelType: Model,
+      projectId: createdItem.projectId,
+      definitionName: "scheduled maintenance custom field",
+    });
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  protected override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (updatedItemIds.length > 0) {
+      backfillMappedCustomFieldValues({
+        definitionModelType: Model,
+        projectId: await this.getProjectIdForBackfill(onUpdate, updatedItemIds),
+        definitionName: "scheduled maintenance custom field",
+      });
+    }
+
+    return onUpdate;
+  }
+
+  /*
+   * `props.tenantId` is set on every dashboard write but not on internal
+   * root-scoped ones, so fall back to the row itself rather than skipping the
+   * backfill for a mapping that was changed by a script.
+   */
+  private async getProjectIdForBackfill(
+    onUpdate: OnUpdate<Model>,
+    updatedItemIds: Array<ObjectID>,
+  ): Promise<ObjectID | undefined> {
+    const tenantId: ObjectID | undefined = onUpdate.updateBy.props.tenantId as
+      | ObjectID
+      | undefined;
+
+    if (tenantId) {
+      return tenantId;
+    }
+
+    const item: Model | null = await this.findOneById({
+      id: updatedItemIds[0]!,
+      select: { projectId: true },
+      props: { isRoot: true },
+    });
+
+    return item?.projectId;
+  }
 }
 export default new Service();

package/Server/Services/ScheduledMaintenanceService.ts

@@ -6,6 +6,8 @@ import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
+import ScheduledMaintenanceCustomField from "../../Models/DatabaseModels/ScheduledMaintenanceCustomField";
+import CustomFieldMappingService from "./CustomFieldMappingService";
 import MonitorService from "./MonitorService";
 import ScheduledMaintenanceOwnerTeamService from "./ScheduledMaintenanceOwnerTeamService";
 import ScheduledMaintenanceOwnerUserService from "./ScheduledMaintenanceOwnerUserService";
@@ -609,6 +611,17 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
 
     await this.validateProjectScopedReferences(updateBy);
 
+    /*
+     * Re-apply mapped custom field values. Covers the Custom Fields modal
+     * saving the whole bag back over a mapped value, and the event's monitors
+     * changing — both change what a mapped field should hold, and folding the
+     * answer into this payload keeps it one write with a truthful audit entry.
+     */
+    await CustomFieldMappingService.applyMappingsToUpdate({
+      definitionModelType: ScheduledMaintenanceCustomField,
+      updateBy: updateBy,
+    });
+
     return {
       updateBy,
       carryForward: null,
@@ -937,6 +950,19 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
         StatusPageSubscriberNotificationStatus.Pending;
     }
 
+    /*
+     * Custom fields configured to inherit from the event's monitors are
+     * stamped here rather than in onCreateSuccess: `customFields` is a column
+     * on this row and the onCreateSuccess chain is un-awaited, so a value
+     * written there would be missing from the event the caller gets back.
+     * Written not to throw — a field failing to inherit must not stop an event
+     * from being scheduled.
+     */
+    await CustomFieldMappingService.applyMappingsToCreate({
+      definitionModelType: ScheduledMaintenanceCustomField,
+      createBy: createBy,
+    });
+
     return { createBy, carryForward: null };
   }
 
@@ -1562,6 +1588,12 @@ ${scheduledMaintenance.description || "No description provided."}
     onUpdate: OnUpdate<Model>,
     updatedItemIds: ObjectID[],
   ): Promise<OnUpdate<Model>> {
+    CustomFieldMappingService.restampAfterMultiRowUpdate({
+      definitionModelType: ScheduledMaintenanceCustomField,
+      updateBy: onUpdate.updateBy,
+      updatedItemIds: updatedItemIds,
+    });
+
     /*
      * Rescheduling the planned window is the whole point of making these
      * fields editable, so the numbers derived from them have to move. Without