@oneuptime/common 14.0.8 → 14.0.10

package/build/dist/Server/Services/ScheduledMaintenanceService.js

@@ -29,6 +29,7 @@ import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import Monitor from "../../Models/DatabaseModels/Monitor";
 import Model from "../../Models/DatabaseModels/ScheduledMaintenance";
 import MonitorStatusService from "./MonitorStatusService";
 import ProjectScopedReferenceValidator, { resolveReferenceId, resolveReferenceIds, } from "../Utils/Database/ProjectScopedReferenceValidator";
@@ -69,6 +70,22 @@ import StatusPageResourceUtil from "../Utils/StatusPageResource";
 import SafeHtml from "../../Types/SafeHtml";
 import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
 import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
+import NetworkSite from "../../Models/DatabaseModels/NetworkSite";
+const ATTACHMENT_COLUMNS = [
+    "monitors",
+    "networkSites",
+];
+/*
+ * Enough of a state to tell which kind it is. A project can add its own
+ * states between the built-in ones, and those are none of the four kinds.
+ */
+const STATE_KIND_SELECT = {
+    _id: true,
+    isScheduledState: true,
+    isOngoingState: true,
+    isEndedState: true,
+    isResolvedState: true,
+};
 export class Service extends DatabaseService {
     constructor() {
         super(Model);
@@ -463,6 +480,11 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
             }
         }
         await this.validateProjectScopedReferences(updateBy);
+        /*
+         * Read before the write, because afterwards the detached monitors are no
+         * longer on the event and nothing else remembers them.
+         */
+        const carryForward = await this.getAttachmentsBeforeUpdate(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
@@ -475,9 +497,123 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
         });
         return {
             updateBy,
-            carryForward: null,
+            carryForward: carryForward,
         };
     }
+    /*
+     * The monitors and network sites each event the update matches holds just
+     * before the write, for onUpdateSuccess to compare with what it holds
+     * after. Null, with nothing read, unless the payload writes one of those
+     * lists.
+     *
+     * Read as root but held to the tenant's project, like the other update
+     * reads here; the permission checks that narrow the write run after this
+     * hook, so an event read here that the write then skips is simply never
+     * looked up again (onUpdateSuccess only visits the rows actually written).
+     */
+    async getAttachmentsBeforeUpdate(updateBy) {
+        var _a;
+        const columns = ATTACHMENT_COLUMNS.filter((column) => {
+            /*
+             * Only a list that is left out is left alone. Null or an empty list
+             * can clear it, and whatever the write makes of any payload is read
+             * back afterwards, so every written list is remembered here.
+             */
+            return updateBy.data[column] !== undefined;
+        });
+        if (columns.length === 0) {
+            return null;
+        }
+        const carryForward = {};
+        /*
+         * One read per list. A find that selects two many-to-many relations
+         * returns a row for every combination of their ids. See
+         * ProjectScopedReferenceValidator.getHeldRelationIds.
+         */
+        for (const column of columns) {
+            const select = {
+                _id: true,
+                projectId: true,
+                currentScheduledMaintenanceState: STATE_KIND_SELECT,
+            };
+            if (column === "monitors") {
+                select.monitors = {
+                    _id: true,
+                };
+            }
+            else {
+                select.networkSites = {
+                    _id: true,
+                };
+            }
+            const scheduledMaintenanceEvents = await this.findBy({
+                query: updateBy.props.tenantId
+                    ? Object.assign(Object.assign({}, updateBy.query), { projectId: updateBy.props.tenantId }) : updateBy.query,
+                select: select,
+                limit: LIMIT_MAX,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            for (const scheduledMaintenanceEvent of scheduledMaintenanceEvents) {
+                if (!scheduledMaintenanceEvent.id) {
+                    continue;
+                }
+                const eventKey = scheduledMaintenanceEvent.id.toString();
+                const attachmentsBeforeUpdate = carryForward[eventKey] || {
+                    projectId: undefined,
+                    wasOngoingBeforeUpdate: false,
+                    wasHoldingMonitorsBeforeUpdate: false,
+                    monitorIdsBeforeUpdate: undefined,
+                    networkSiteIdsBeforeUpdate: undefined,
+                };
+                attachmentsBeforeUpdate.projectId = scheduledMaintenanceEvent.projectId;
+                attachmentsBeforeUpdate.wasOngoingBeforeUpdate = Boolean((_a = scheduledMaintenanceEvent.currentScheduledMaintenanceState) === null || _a === void 0 ? void 0 : _a.isOngoingState);
+                if (column === "monitors") {
+                    attachmentsBeforeUpdate.monitorIdsBeforeUpdate = this.getIdsNotIn({
+                        ids: resolveReferenceIds(scheduledMaintenanceEvent.monitors),
+                        exclude: [],
+                    });
+                    // Only monitors are held; sites follow the live state.
+                    attachmentsBeforeUpdate.wasHoldingMonitorsBeforeUpdate =
+                        await ScheduledMaintenanceStateTimelineService.isScheduledMaintenanceHoldingMonitors({
+                            scheduledMaintenanceId: scheduledMaintenanceEvent.id,
+                            projectId: scheduledMaintenanceEvent.projectId,
+                            currentState: scheduledMaintenanceEvent.currentScheduledMaintenanceState,
+                        });
+                }
+                else {
+                    attachmentsBeforeUpdate.networkSiteIdsBeforeUpdate = this.getIdsNotIn({
+                        ids: resolveReferenceIds(scheduledMaintenanceEvent.networkSites),
+                        exclude: [],
+                    });
+                }
+                carryForward[eventKey] = attachmentsBeforeUpdate;
+            }
+        }
+        return carryForward;
+    }
+    /*
+     * The ids in `ids` that `exclude` does not hold, each once and lower-cased
+     * (with nothing to exclude, a list read the same way). Compared case-blind,
+     * so an id that reached one side in another case is never reported as
+     * both removed and added.
+     */
+    getIdsNotIn(data) {
+        const excludedKeys = new Set(data.exclude.map((id) => {
+            return id.toString().trim().toLowerCase();
+        }));
+        const result = new Map();
+        for (const id of data.ids) {
+            const key = id.toString().trim().toLowerCase();
+            if (!key || excludedKeys.has(key) || result.has(key)) {
+                continue;
+            }
+            result.set(key, new ObjectID(key));
+        }
+        return Array.from(result.values());
+    }
     /*
      * An update can repoint a scheduled maintenance event at another project's
      * state or monitor status just as easily as a create can, and the result is
@@ -1237,8 +1373,349 @@ ${scheduledMaintenance.description || "No description provided."}
             "Changed because of scheduled maintenance event: " + item.id.toString(), undefined, props);
         }
     }
+    /*
+     * What the write actually changed on one event: its lists as read back
+     * now, against the ones onBeforeUpdate read before the write. Comparing
+     * with the payload instead would trust entries the write may have dropped
+     * (see AttachmentsBeforeUpdate) - a monitor put into maintenance without
+     * being attached could never be restored, since ending or deleting the
+     * event only reaches the monitors it holds.
+     *
+     * The monitors are read back whenever they were written, because the feed
+     * names the change on any event. The sites are only needed by an event
+     * that was suppressing them.
+     */
+    async getAttachmentChange(data) {
+        const attachmentsBeforeUpdate = data.attachmentsBeforeUpdate;
+        const change = {
+            monitorsAdded: [],
+            monitorsRemoved: [],
+            networkSitesChanged: [],
+            eventAfterUpdate: null,
+        };
+        const monitorIdsBeforeUpdate = attachmentsBeforeUpdate.monitorIdsBeforeUpdate;
+        if (monitorIdsBeforeUpdate) {
+            const eventAfterUpdate = await this.findOneById({
+                id: data.scheduledMaintenanceId,
+                select: {
+                    _id: true,
+                    changeMonitorStatusToId: true,
+                    currentScheduledMaintenanceState: STATE_KIND_SELECT,
+                    monitors: {
+                        _id: true,
+                    },
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            /*
+             * An event that cannot be read back was deleted since the write, and
+             * its delete hook deals with whatever it held.
+             */
+            if (eventAfterUpdate) {
+                const monitorIdsAfterUpdate = resolveReferenceIds(eventAfterUpdate.monitors);
+                change.monitorsAdded = this.getIdsNotIn({
+                    ids: monitorIdsAfterUpdate,
+                    exclude: monitorIdsBeforeUpdate,
+                });
+                change.monitorsRemoved = this.getIdsNotIn({
+                    ids: monitorIdsBeforeUpdate,
+                    exclude: monitorIdsAfterUpdate,
+                });
+                change.eventAfterUpdate = eventAfterUpdate;
+            }
+        }
+        const networkSiteIdsBeforeUpdate = attachmentsBeforeUpdate.networkSiteIdsBeforeUpdate;
+        if (networkSiteIdsBeforeUpdate &&
+            attachmentsBeforeUpdate.wasOngoingBeforeUpdate) {
+            // A read of its own, for the same reason as in onBeforeUpdate.
+            const eventAfterUpdate = await this.findOneById({
+                id: data.scheduledMaintenanceId,
+                select: {
+                    _id: true,
+                    networkSites: {
+                        _id: true,
+                    },
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (eventAfterUpdate) {
+                const networkSiteIdsAfterUpdate = resolveReferenceIds(eventAfterUpdate.networkSites);
+                change.networkSitesChanged = [
+                    ...this.getIdsNotIn({
+                        ids: networkSiteIdsAfterUpdate,
+                        exclude: networkSiteIdsBeforeUpdate,
+                    }),
+                    ...this.getIdsNotIn({
+                        ids: networkSiteIdsBeforeUpdate,
+                        exclude: networkSiteIdsAfterUpdate,
+                    }),
+                ];
+            }
+        }
+        return change;
+    }
+    /*
+     * Moving to ongoing puts the attached monitors into maintenance (the flag
+     * that stops probing, and the configured status) and ending restores the
+     * ones attached at that moment. Both read the list only at the transition,
+     * so a monitor detached mid-window would stay disabled for good - ending
+     * or deleting the event no longer reaches it, and the flag is not
+     * user-editable - and one attached mid-window would keep being probed and
+     * alerting. This does for the edited part of the list what the
+     * transitions did for the rest.
+     *
+     * Monitors are acted on while the event holds them (see
+     * ScheduledMaintenanceStateTimelineService.isScheduledMaintenanceHoldingMonitors):
+     * a scheduled event picks up its list when it starts, and an ended one
+     * has nothing held. Network sites are suppressed only while the event is
+     * live in an ongoing state.
+     *
+     * The write has already committed, so nothing here may undo it or turn it
+     * into an error. Each step fails on its own, and each monitor within a
+     * step, logged; the steps after it still run.
+     */
+    async applyAttachmentChangeToEvent(data) {
+        const attachmentsBeforeUpdate = data.attachmentsBeforeUpdate;
+        const change = data.change;
+        const projectId = attachmentsBeforeUpdate.projectId;
+        if (!projectId) {
+            return;
+        }
+        const logAttributes = {
+            projectId: projectId.toString(),
+            scheduledMaintenanceId: data.scheduledMaintenanceId.toString(),
+        };
+        const wasHoldingMonitorsBeforeUpdate = attachmentsBeforeUpdate.wasHoldingMonitorsBeforeUpdate;
+        /*
+         * Whether the event holds its monitors now, as read back after the write
+         * and after any state change the same update made. The state can also
+         * move between onBeforeUpdate's read and the write - the
+         * ChangeStateToOngoing job starting the event, or another request
+         * changing its state - so the state before the write cannot decide
+         * either list alone. Read only when it can change what happens.
+         *
+         * If it cannot be read, nothing new is held: a monitor probed through
+         * the window is better than one disabled with nothing to restore it.
+         */
+        let isHoldingMonitorsAfterUpdate = false;
+        if (change.eventAfterUpdate &&
+            (change.monitorsAdded.length > 0 ||
+                (change.monitorsRemoved.length > 0 && !wasHoldingMonitorsBeforeUpdate))) {
+            try {
+                isHoldingMonitorsAfterUpdate =
+                    await ScheduledMaintenanceStateTimelineService.isScheduledMaintenanceHoldingMonitors({
+                        scheduledMaintenanceId: data.scheduledMaintenanceId,
+                        projectId: projectId,
+                        currentState: change.eventAfterUpdate.currentScheduledMaintenanceState,
+                    });
+            }
+            catch (err) {
+                logger.error(`ScheduledMaintenanceService.applyAttachmentChangeToEvent: could not read whether scheduled maintenance ${data.scheduledMaintenanceId.toString()} holds its monitors after the update; holding none of the monitors it attached.`, logAttributes);
+                logger.error(err, logAttributes);
+            }
+        }
+        /*
+         * A detached monitor is released if the event held its monitors on
+         * either side of the write: before it, or after it when the event
+         * started in between and the transition flagged the list it read then,
+         * which may still have had this monitor on it. Only the monitors
+         * actually flagged are released (see restoreMonitorsDetachedFromEvent).
+         */
+        if (change.monitorsRemoved.length > 0 &&
+            (wasHoldingMonitorsBeforeUpdate || isHoldingMonitorsAfterUpdate)) {
+            try {
+                await this.restoreMonitorsDetachedFromEvent({
+                    scheduledMaintenanceId: data.scheduledMaintenanceId,
+                    projectId: projectId,
+                    monitorIds: change.monitorsRemoved,
+                });
+            }
+            catch (err) {
+                logger.error(`ScheduledMaintenanceService.applyAttachmentChangeToEvent: could not restore the monitors detached from scheduled maintenance ${data.scheduledMaintenanceId.toString()}.`, logAttributes);
+                logger.error(err, logAttributes);
+            }
+        }
+        /*
+         * An attached monitor is held when the event holds its monitors after
+         * the write, whatever it was doing before: the job (or another request)
+         * can have started it between onBeforeUpdate's read and the write,
+         * flagging the list without this monitor. A transition that ran after
+         * the write - the same update started the event, or the job did just
+         * after - has reached this monitor already, and holding it again
+         * changes nothing. An event the same update ended has had its whole list
+         * restored by the transition, and holds nothing.
+         */
+        if (change.monitorsAdded.length > 0 &&
+            isHoldingMonitorsAfterUpdate &&
+            change.eventAfterUpdate) {
+            await this.holdMonitorsAttachedToEvent({
+                scheduledMaintenanceId: data.scheduledMaintenanceId,
+                projectId: projectId,
+                monitorIds: change.monitorsAdded,
+                changeMonitorStatusToId: change.eventAfterUpdate.changeMonitorStatusToId,
+            });
+        }
+        /*
+         * Sites are suppressed by the live attachment, so the edit itself has
+         * already taken effect; this only re-rolls the chains now rather than at
+         * the next stale sweep, as the state transition does. Detached sites
+         * need it as much as attached ones: they were suppressed until now.
+         * recomputeNetworkSiteRollups logs its own failures.
+         */
+        if (attachmentsBeforeUpdate.wasOngoingBeforeUpdate &&
+            change.networkSitesChanged.length > 0) {
+            const eventWithChangedSites = new Model(data.scheduledMaintenanceId);
+            eventWithChangedSites.projectId = projectId;
+            eventWithChangedSites.networkSites = change.networkSitesChanged.map((siteId) => {
+                return new NetworkSite(siteId);
+            });
+            await ScheduledMaintenanceStateTimelineService.recomputeNetworkSiteRollups(eventWithChangedSites);
+        }
+    }
+    /*
+     * Releases the monitors an edit detached from an event that was holding
+     * them, exactly as ending the event releases its list:
+     * enableActiveMonitoringForMonitors clears the flag and puts each back in
+     * the operational status, skipping a monitor another event still holds
+     * and carrying on past one that fails. This event no longer counts as
+     * holding them: the write has already removed them from it.
+     *
+     * Only a monitor whose flag is set is released. That the event held its
+     * monitors says it held the list it read when it started, not that it
+     * held this monitor: an event the same update (or the job, just after the
+     * write) started never flagged a monitor the write had already detached,
+     * and one ended by another request just before the write has released it
+     * already. Released anyway, that monitor would be forced into the
+     * operational status over the one it is really in.
+     */
+    async restoreMonitorsDetachedFromEvent(data) {
+        const heldMonitors = await MonitorService.findBy({
+            query: {
+                _id: QueryHelper.any(data.monitorIds),
+                projectId: data.projectId,
+                disableActiveMonitoringBecauseOfScheduledMaintenanceEvent: true,
+            },
+            select: {
+                _id: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        if (heldMonitors.length === 0) {
+            return;
+        }
+        const eventWithRemovedMonitors = new Model(data.scheduledMaintenanceId);
+        eventWithRemovedMonitors.projectId = data.projectId;
+        eventWithRemovedMonitors.monitors = this.getIdsNotIn({
+            ids: resolveReferenceIds(heldMonitors),
+            exclude: [],
+        }).map((monitorId) => {
+            return new Monitor(monitorId);
+        });
+        await ScheduledMaintenanceStateTimelineService.enableActiveMonitoringForMonitors(eventWithRemovedMonitors);
+    }
+    /*
+     * Puts the monitors an edit attached into maintenance, as entering ongoing
+     * does for the list (ScheduledMaintenanceStateTimelineService): the flag
+     * that stops probing, then the status the event applies, if any. Both are
+     * idempotent, so a monitor the transition has reached as well - the event
+     * started just after the write - is left as it is.
+     *
+     * One monitor at a time, as the release is: one that fails must not leave
+     * the rest of what the edit attached probed and alerting through the
+     * window.
+     */
+    async holdMonitorsAttachedToEvent(data) {
+        for (const monitorId of data.monitorIds) {
+            try {
+                await MonitorService.updateOneById({
+                    id: monitorId,
+                    data: {
+                        disableActiveMonitoringBecauseOfScheduledMaintenanceEvent: true, /// This will stop active monitoring.
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const eventWithAddedMonitor = new Model(data.scheduledMaintenanceId);
+                eventWithAddedMonitor.projectId = data.projectId;
+                eventWithAddedMonitor.monitors = [new Monitor(monitorId)];
+                if (data.changeMonitorStatusToId) {
+                    eventWithAddedMonitor.changeMonitorStatusToId =
+                        data.changeMonitorStatusToId;
+                }
+                // A no-op when the event does not change monitor status.
+                await this.changeAttachedMonitorStates(eventWithAddedMonitor, {
+                    isRoot: true,
+                });
+            }
+            catch (err) {
+                const logAttributes = {
+                    projectId: data.projectId.toString(),
+                    scheduledMaintenanceId: data.scheduledMaintenanceId.toString(),
+                    monitorId: monitorId.toString(),
+                };
+                logger.error(`ScheduledMaintenanceService.holdMonitorsAttachedToEvent: could not put monitor ${monitorId.toString()} into maintenance; continuing with the remaining monitors.`, logAttributes);
+                logger.error(err, logAttributes);
+                continue;
+            }
+        }
+    }
+    /*
+     * "Monitors Removed" / "Monitors Added" for the updated feed item, worded
+     * as the incident feed words them. The names are read back held to the
+     * project, so an id that is not this project's monitor is never named.
+     */
+    async getMonitorChangesFeedMarkdown(data) {
+        const sections = [
+            {
+                title: "🗑️ Monitors Removed",
+                monitorIds: data.change.monitorsRemoved,
+            },
+            {
+                title: "🌎 Monitors Added",
+                monitorIds: data.change.monitorsAdded,
+            },
+        ];
+        let markdown = "";
+        for (const section of sections) {
+            if (section.monitorIds.length === 0) {
+                continue;
+            }
+            const monitors = await MonitorService.findBy({
+                query: {
+                    _id: QueryHelper.any(section.monitorIds),
+                    projectId: data.projectId,
+                },
+                select: {
+                    _id: true,
+                    name: true,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (monitors.length === 0) {
+                continue;
+            }
+            markdown += `\n\n**${section.title}**:\n`;
+            for (const monitor of monitors) {
+                markdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(data.projectId, monitor.id)).toString()})\n`;
+            }
+        }
+        return markdown;
+    }
     async onUpdateSuccess(onUpdate, updatedItemIds) {
-        var _a;
+        var _a, _b, _c, _d;
         CustomFieldMappingService.restampAfterMultiRowUpdate({
             definitionModelType: ScheduledMaintenanceCustomField,
             updateBy: onUpdate.updateBy,
@@ -1284,6 +1761,35 @@ ${scheduledMaintenance.description || "No description provided."}
                 let shouldAddScheduledMaintenanceFeed = false;
                 let feedInfoInMarkdown = "**Scheduled Maintenance was updated.**";
                 const createdByUserId = onUpdate.updateBy.props.userId;
+                const attachmentsBeforeUpdate = (_a = onUpdate.carryForward) === null || _a === void 0 ? void 0 : _a[scheduledMaintenanceId.toString()];
+                let attachmentChange = null;
+                if (attachmentsBeforeUpdate) {
+                    /*
+                     * The update is saved by now. Whatever fails here is logged, and
+                     * the feed item and the other events of a bulk update still
+                     * follow - with the change named in the feed, when it was read
+                     * back before the failure.
+                     */
+                    try {
+                        attachmentChange = await this.getAttachmentChange({
+                            scheduledMaintenanceId: scheduledMaintenanceId,
+                            attachmentsBeforeUpdate: attachmentsBeforeUpdate,
+                        });
+                        await this.applyAttachmentChangeToEvent({
+                            scheduledMaintenanceId: scheduledMaintenanceId,
+                            attachmentsBeforeUpdate: attachmentsBeforeUpdate,
+                            change: attachmentChange,
+                        });
+                    }
+                    catch (err) {
+                        const logAttributes = {
+                            projectId: (_b = attachmentsBeforeUpdate.projectId) === null || _b === void 0 ? void 0 : _b.toString(),
+                            scheduledMaintenanceId: scheduledMaintenanceId.toString(),
+                        };
+                        logger.error(`ScheduledMaintenanceService.onUpdateSuccess: could not apply the edit of the monitors or network sites of scheduled maintenance ${scheduledMaintenanceId.toString()}; the update itself is saved.`, logAttributes);
+                        logger.error(err, logAttributes);
+                    }
+                }
                 if (onUpdate.updateBy.data.title) {
                     // add scheduledMaintenance feed.
                     feedInfoInMarkdown += `\n\n**Title**: 
@@ -1356,6 +1862,32 @@ ${LinkedAffectedResources.getMarkdownLines({
                         shouldAddScheduledMaintenanceFeed = true;
                     }
                 }
+                /*
+                 * The list above is what the event affects now; these say what the
+                 * edit changed. Removing every monitor leaves no list to show, and
+                 * without this the feed would not record the edit at all.
+                 */
+                if (attachmentChange && onUpdate.updateBy.props.tenantId) {
+                    // A line the names could not be read for is left out, not the item.
+                    try {
+                        const monitorChangesMarkdown = await this.getMonitorChangesFeedMarkdown({
+                            projectId: onUpdate.updateBy.props.tenantId,
+                            change: attachmentChange,
+                        });
+                        if (monitorChangesMarkdown) {
+                            feedInfoInMarkdown += monitorChangesMarkdown;
+                            shouldAddScheduledMaintenanceFeed = true;
+                        }
+                    }
+                    catch (err) {
+                        const logAttributes = {
+                            projectId: (_c = onUpdate.updateBy.props.tenantId) === null || _c === void 0 ? void 0 : _c.toString(),
+                            scheduledMaintenanceId: scheduledMaintenanceId.toString(),
+                        };
+                        logger.error(`ScheduledMaintenanceService.onUpdateSuccess: could not name the monitors added to or removed from scheduled maintenance ${scheduledMaintenanceId.toString()} in its feed.`, logAttributes);
+                        logger.error(err, logAttributes);
+                    }
+                }
                 if (onUpdate.updateBy.data.statusPages &&
                     onUpdate.updateBy.data.statusPages.length > 0 &&
                     Array.isArray(onUpdate.updateBy.data.statusPages)) {
@@ -1459,7 +1991,7 @@ ${labels
                     }
                     catch (reminderError) {
                         logger.error(`Reminder rescheduling failed in ScheduledMaintenanceService.onUpdateSuccess: ${reminderError}`, {
-                            projectId: (_a = onUpdate.updateBy.props.tenantId) === null || _a === void 0 ? void 0 : _a.toString(),
+                            projectId: (_d = onUpdate.updateBy.props.tenantId) === null || _d === void 0 ? void 0 : _d.toString(),
                             scheduledMaintenanceId: scheduledMaintenanceId === null || scheduledMaintenanceId === void 0 ? void 0 : scheduledMaintenanceId.toString(),
                         });
                     }