@oneuptime/common 14.0.8 → 14.0.10

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

@@ -328,11 +328,11 @@ export class Service extends DatabaseService {
     }
     async onBeforeUpdate(updateBy) {
         /*
-         * get monitors for this incident.
-         * if the monitors are removed then change them to operational state.
-         * then change all of the monitors in this incident to the changeMonitorStatusToId.
+         * Records which monitors the update takes off and puts on each incident,
+         * the monitor status it writes, and whether the incident was resolved
+         * before it, for onUpdateSuccess to decide what that does to the
+         * monitors (updateMonitorsForIncidentEdit).
          */
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         updateBy.query = applyIncidentSelfPrivacyFilter(updateBy.query, updateBy.props);
         if (updateBy.data.isPrivate === true) {
             updateBy.data.isVisibleOnStatusPage = false;
@@ -348,7 +348,16 @@ export class Service extends DatabaseService {
         const isCreatedNotificationResendRequested = this.isCreatedNotificationResendRequested(updateBy);
         await this.validateProjectScopedReferences(updateBy);
         const carryForward = {};
-        if (updateBy.data.monitors ||
+        const data = updateBy.data;
+        /*
+         * Only an update that sends the monitor list changes which monitors the
+         * incident holds. One that sends just the monitor status (the API, the
+         * CLI or a workflow) takes no monitor off: reading the missing list as
+         * empty would restore every monitor, and walking it threw. A list set to
+         * null is sent: TypeORM clears a many-to-many set to null, like [].
+         */
+        const isMonitorListUpdated = data["monitors"] !== undefined;
+        if (isMonitorListUpdated ||
             updateBy.data.changeMonitorStatusTo ||
             updateBy.data.changeMonitorStatusToId) {
             const incidentsToUpdate = await this.findBy({
@@ -364,46 +373,54 @@ export class Service extends DatabaseService {
                 skip: 0,
                 props: updateBy.props,
             });
+            /*
+             * The monitor status the update writes, in any shape the API accepts
+             * (an id, a bare uuid string or a relation object), so the status an
+             * update writes is never mistaken for one it leaves alone.
+             */
+            const monitorStatusIdInUpdate = resolveReferenceId(data["changeMonitorStatusToId"]) ||
+                resolveReferenceId(data["changeMonitorStatusTo"]);
+            const newMonitorChangeStatusIdTo = monitorStatusIdInUpdate
+                ? new ObjectID(monitorStatusIdInUpdate.toString())
+                : undefined;
+            const isChangeMonitorStatusToCleared = !newMonitorChangeStatusIdTo &&
+                (data["changeMonitorStatusToId"] === null ||
+                    data["changeMonitorStatusTo"] === null);
+            const monitorIdsAfterUpdate = isMonitorListUpdated
+                ? this.getMonitorIdsInUpdate(data["monitors"])
+                : [];
             for (const incident of incidentsToUpdate) {
+                const storedMonitors = incident.monitors || [];
+                const storedMonitorIds = storedMonitors.map((monitor) => {
+                    return this.getMonitorIdForComparison(monitor);
+                });
+                const monitorsRemoved = isMonitorListUpdated
+                    ? storedMonitors.filter((monitor) => {
+                        return !monitorIdsAfterUpdate.includes(this.getMonitorIdForComparison(monitor));
+                    })
+                    : [];
                 carryForward[incident.id.toString()] = {
-                    monitorsRemoved: [],
-                    monitorsAdded: [],
+                    monitorsRemoved: monitorsRemoved,
+                    /*
+                     * Read now, before the write: an update that resolves the incident
+                     * and takes a monitor off must still restore that monitor, and one
+                     * that reopens a resolved incident must not restore it twice.
+                     * After the write, the state no longer tells these cases apart.
+                     */
+                    isResolvedBeforeUpdate: monitorsRemoved.length > 0
+                        ? await this.isIncidentResolved({ incidentId: incident.id })
+                        : undefined,
+                    monitorsAdded: monitorIdsAfterUpdate
+                        .filter((monitorId) => {
+                        return !storedMonitorIds.includes(monitorId);
+                    })
+                        .map((monitorId) => {
+                        return new Monitor(new ObjectID(monitorId));
+                    }),
                     oldChangeMonitorStatusIdTo: incident.changeMonitorStatusToId,
-                    newMonitorChangeStatusIdTo: updateBy.data.changeMonitorStatusToId ||
-                        ((_a = updateBy.data.changeMonitorStatusTo) === null || _a === void 0 ? void 0 : _a._id) ||
-                        undefined,
+                    newMonitorChangeStatusIdTo: newMonitorChangeStatusIdTo,
+                    isChangeMonitorStatusToCleared: isChangeMonitorStatusToCleared,
                 };
-                for (const monitor of incident.monitors || []) {
-                    // check if this monitor is actually removed.
-                    let isRemoved = true;
-                    for (const updatedMonitor of (_b = updateBy.data) === null || _b === void 0 ? void 0 : _b.monitors) {
-                        if (updatedMonitor._id &&
-                            updatedMonitor._id.toString() === ((_c = monitor._id) === null || _c === void 0 ? void 0 : _c.toString())) {
-                            isRemoved = false;
-                            break;
-                        }
-                    }
-                    if (isRemoved) {
-                        (_e = (_d = carryForward[incident.id.toString()]) === null || _d === void 0 ? void 0 : _d.monitorsRemoved) === null || _e === void 0 ? void 0 : _e.push(monitor);
-                    }
-                }
-                if (updateBy.data.monitors && updateBy.data.monitors.length > 0) {
-                    for (const monitor of (_f = updateBy.data) === null || _f === void 0 ? void 0 : _f.monitors) {
-                        // check if this monitor is actually added.
-                        let isAdded = true;
-                        for (const existingMonitor of incident.monitors || []) {
-                            if (existingMonitor._id &&
-                                existingMonitor._id.toString() === ((_g = monitor._id) === null || _g === void 0 ? void 0 : _g.toString())) {
-                                isAdded = false;
-                                break;
-                            }
-                        }
-                        if (isAdded) {
-                            // this monitor is added.
-                            (_j = (_h = carryForward[incident.id.toString()]) === null || _h === void 0 ? void 0 : _h.monitorsAdded) === null || _j === void 0 ? void 0 : _j.push(monitor);
-                        }
-                    }
-                }
             }
         }
         // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnIncidentCreated if it's being updated
@@ -462,6 +479,31 @@ export class Service extends DatabaseService {
             carryForward: carryForward,
         };
     }
+    /*
+     * The ids of the monitors an update's list holds, deduplicated and
+     * lowercased like getMonitorIdForComparison. The list reaches the hook as
+     * models, `{ _id }` objects, ObjectIDs or bare uuid strings (API update),
+     * and comparing only `_id` read every bare id as a monitor taken off and
+     * put back on again.
+     */
+    getMonitorIdsInUpdate(monitors) {
+        const monitorIds = [];
+        for (const monitorId of resolveReferenceIds(monitors)) {
+            const normalizedMonitorId = monitorId
+                .toString()
+                .trim()
+                .toLowerCase();
+            if (!monitorIds.includes(normalizedMonitorId)) {
+                monitorIds.push(normalizedMonitorId);
+            }
+        }
+        return monitorIds;
+    }
+    // A monitor's id as getMonitorIdsInUpdate writes it, for comparing the two.
+    getMonitorIdForComparison(monitor) {
+        var _a;
+        return (((_a = monitor._id) === null || _a === void 0 ? void 0 : _a.toString()) || "").trim().toLowerCase();
+    }
     /*
      * The incidents an update will write to, as they are stored, for the hooks
      * below that decide what else joins the update.
@@ -2773,7 +2815,7 @@ ${incident.remediationNotes || "No remediation notes provided."}
         return URL.fromString(dashboardUrl.toString()).addRoute(`/${projectId.toString()}/incidents/${incidentId.toString()}`);
     }
     async onUpdateSuccess(onUpdate, updatedItemIds) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         CustomFieldMappingService.restampAfterMultiRowUpdate({
             definitionModelType: IncidentCustomField,
             updateBy: onUpdate.updateBy,
@@ -3202,8 +3244,6 @@ ${incidentSeverity.name}
                                     isRoot: true,
                                 },
                             });
-                            // change these monitors back to operational state.
-                            await this.markMonitorsActiveForMonitoring(projectId, incidentCarryForward.monitorsRemoved);
                             feedInfoInMarkdown += `\n\n**🗑️ Monitors Removed**:\n`;
                             for (const monitor of monitorsRemoved) {
                                 feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(projectId, monitor.id)).toString()})\n`;
@@ -3247,8 +3287,10 @@ ${incidentSeverity.name}
                             incidentId: incidentId,
                             change: incidentCarryForward.statusPageScopeChange,
                         });
+                        // Saving the status the incident already had changes nothing.
                         if (incidentCarryForward.oldChangeMonitorStatusIdTo &&
-                            incidentCarryForward.newMonitorChangeStatusIdTo) {
+                            incidentCarryForward.newMonitorChangeStatusIdTo &&
+                            this.isMonitorStatusChangedByUpdate(incidentCarryForward)) {
                             const oldMonitorStatus = await MonitorStatusService.findOneBy({
                                 query: {
                                     _id: incidentCarryForward.oldChangeMonitorStatusIdTo,
@@ -3276,33 +3318,13 @@ ${incidentSeverity.name}
                                 shouldAddIncidentFeed = true;
                             }
                         }
-                        const changeNewMonitorStatusTo = incidentCarryForward.newMonitorChangeStatusIdTo ||
-                            incidentCarryForward.oldChangeMonitorStatusIdTo;
-                        if (((_e = incidentCarryForward.monitorsAdded) === null || _e === void 0 ? void 0 : _e.length) > 0) {
-                            await this.disableActiveMonitoringIfManualIncident(incidentId);
-                        }
-                        if (changeNewMonitorStatusTo) {
-                            const incident = await this.findOneById({
-                                id: incidentId,
-                                select: {
-                                    projectId: true,
-                                    monitors: {
-                                        _id: true,
-                                    },
-                                },
-                                props: {
-                                    isRoot: true,
-                                },
-                            });
-                            const monitorsForThisIncident = (incident === null || incident === void 0 ? void 0 : incident.monitors) || [];
-                            await MonitorService.changeMonitorStatus(projectId, monitorsForThisIncident.map((monitor) => {
-                                var _a;
-                                return new ObjectID(((_a = monitor._id) === null || _a === void 0 ? void 0 : _a.toString()) || "");
-                            }), changeNewMonitorStatusTo, true, // notifyMonitorOwners
-                            "Status was changed because Incident " +
-                                incidentNumberDisplay +
-                                " was updated.", undefined, onUpdate.updateBy.props);
-                        }
+                        await this.updateMonitorsForIncidentEdit({
+                            projectId: projectId,
+                            incidentId: incidentId,
+                            incidentNumberDisplay: incidentNumberDisplay,
+                            carryForward: incidentCarryForward,
+                            props: onUpdate.updateBy.props,
+                        });
                     }
                 }
                 if (shouldAddIncidentFeed) {
@@ -3322,6 +3344,111 @@ ${incidentSeverity.name}
         }
         return onUpdate;
     }
+    /*
+     * Whether an update puts the incident's monitors in a different status
+     * from the one it held: it writes a status, and not the same one again.
+     */
+    isMonitorStatusChangedByUpdate(carryForward) {
+        var _a;
+        if (!carryForward.newMonitorChangeStatusIdTo) {
+            return false;
+        }
+        return (carryForward.newMonitorChangeStatusIdTo.toString().toLowerCase() !==
+            (((_a = carryForward.oldChangeMonitorStatusIdTo) === null || _a === void 0 ? void 0 : _a.toString()) || "").toLowerCase());
+    }
+    /*
+     * What an edit of an incident's monitors, or of the status it puts them
+     * in, does to the monitors themselves. The feed item records the edit
+     * either way; this only decides which monitors change.
+     *
+     * The monitors taken off the incident are restored, unless another open
+     * incident still holds them (markMonitorsActiveForMonitoring), when the
+     * incident was open before the update. That includes an update that
+     * resolves it as well: resolving restores only the monitors it still
+     * holds (IncidentStateTimelineService), so this is the only restore the
+     * ones taken off get. A monitor taken off an incident that was resolved
+     * already was restored when it resolved, and restoring it again could
+     * overwrite a status set since (maintenance, or a manual monitor's status
+     * set by hand).
+     *
+     * A resolved incident, as it stands after the update, does nothing else
+     * to its monitors. Nothing would clear what it did: an added monitor of a
+     * manual incident would never be probed again, and the incident's status
+     * would sit on its monitors as false downtime.
+     *
+     * An open incident:
+     * - stops probing the monitors of a manual incident when one is added,
+     *   as creating it did (disableActiveMonitoringIfManualIncident);
+     * - puts the monitors added in its status, and all of its monitors only
+     *   when the edit changes that status. Every save used to put all of them
+     *   in it again, overwriting a status a probe had set since.
+     */
+    async updateMonitorsForIncidentEdit(data) {
+        const carryForward = data.carryForward;
+        if (carryForward.monitorsRemoved.length > 0 &&
+            !carryForward.isResolvedBeforeUpdate) {
+            // change these monitors back to operational state.
+            await this.markMonitorsActiveForMonitoring(data.projectId, carryForward.monitorsRemoved);
+        }
+        const isMonitorStatusChanged = this.isMonitorStatusChangedByUpdate(carryForward);
+        if (carryForward.monitorsAdded.length === 0 && !isMonitorStatusChanged) {
+            return;
+        }
+        /*
+         * Read after the update is written, so an edit that resolves the
+         * incident as well counts as resolved: changing the state restored the
+         * monitors it holds, the added ones included.
+         */
+        if (await this.isIncidentResolved({ incidentId: data.incidentId })) {
+            return;
+        }
+        if (carryForward.monitorsAdded.length > 0) {
+            await this.disableActiveMonitoringIfManualIncident(data.incidentId);
+        }
+        // The status the incident puts its monitors in after the update.
+        const monitorStatusIdToApply = carryForward.isChangeMonitorStatusToCleared
+            ? undefined
+            : carryForward.newMonitorChangeStatusIdTo ||
+                carryForward.oldChangeMonitorStatusIdTo;
+        if (!monitorStatusIdToApply ||
+            (!isMonitorStatusChanged && carryForward.monitorsAdded.length === 0)) {
+            return;
+        }
+        const addedMonitorIds = carryForward.monitorsAdded.map((monitor) => {
+            return this.getMonitorIdForComparison(monitor);
+        });
+        /*
+         * The monitors the incident holds now, so a status is only ever put on
+         * a monitor the update left on it.
+         */
+        const incident = await this.findOneById({
+            id: data.incidentId,
+            select: {
+                monitors: {
+                    _id: true,
+                },
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        const monitorIdsToChange = ((incident === null || incident === void 0 ? void 0 : incident.monitors) || [])
+            .filter((monitor) => {
+            return (isMonitorStatusChanged ||
+                addedMonitorIds.includes(this.getMonitorIdForComparison(monitor)));
+        })
+            .map((monitor) => {
+            var _a;
+            return new ObjectID(((_a = monitor._id) === null || _a === void 0 ? void 0 : _a.toString()) || "");
+        });
+        if (monitorIdsToChange.length === 0) {
+            return;
+        }
+        await MonitorService.changeMonitorStatus(data.projectId, monitorIdsToChange, monitorStatusIdToApply, true, // notifyMonitorOwners
+        "Status was changed because Incident " +
+            data.incidentNumberDisplay +
+            " was updated.", undefined, data.props);
+    }
     /*
      * The part of an update's feed item that records a change of the status
      * pages the incident is limited to: the pages added and removed, whether