@oneuptime/common 7.0.4137 → 7.0.4142

package/Server/Services/MonitorStatusTimelineService.ts

@@ -37,7 +37,7 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
     try {
       mutex = await Semaphore.lock({
         key: createBy.data.monitorId.toString(),
-        namespace: "MonitorStatusTimeline.onBeforeCreate",
+        namespace: "MonitorStatusTimeline.create",
       });
     } catch (e) {
       logger.error(e);
@@ -73,6 +73,13 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       }
     }
 
+    const monitorStatusId: ObjectID | undefined | null =
+      createBy.data.monitorStatusId || createBy.data.monitorStatus?.id;
+
+    if (!monitorStatusId) {
+      throw new BadDataException("monitorStatusId is null");
+    }
+
     const stateBeforeThis: MonitorStatusTimeline | null = await this.findOneBy({
       query: {
         monitorId: createBy.data.monitorId,
@@ -100,6 +107,20 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       createBy.data.isOwnerNotified = true;
     }
 
+    // check if this new state and the previous state are same.
+    // if yes, then throw bad data exception.
+
+    if (stateBeforeThis && stateBeforeThis.monitorStatusId && monitorStatusId) {
+      if (
+        stateBeforeThis.monitorStatusId.toString() ===
+        monitorStatusId.toString()
+      ) {
+        throw new BadDataException(
+          "Monitor Status cannot be same as previous status.",
+        );
+      }
+    }
+
     const stateAfterThis: MonitorStatusTimeline | null = await this.findOneBy({
       query: {
         monitorId: createBy.data.monitorId,
@@ -123,6 +144,19 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       createBy.data.endsAt = stateAfterThis.startsAt;
     }
 
+    // check if this new state and the previous state are same.
+    // if yes, then throw bad data exception.
+
+    if (stateAfterThis && stateAfterThis.monitorStatusId && monitorStatusId) {
+      if (
+        stateAfterThis.monitorStatusId.toString() === monitorStatusId.toString()
+      ) {
+        throw new BadDataException(
+          "Monitor Status cannot be same as next status.",
+        );
+      }
+    }
+
     logger.debug("State After this");
     logger.debug(stateAfterThis);
 

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -29,6 +29,7 @@ import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 
 export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline> {
   public constructor() {
@@ -93,96 +94,197 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
       throw new BadDataException("scheduledMaintenanceId is null");
     }
 
-    if (!createBy.data.startsAt) {
-      createBy.data.startsAt = OneUptimeDate.getCurrentDate();
-    }
+    let mutex: SemaphoreMutex | null = null;
 
-    const stateBeforeThis: ScheduledMaintenanceStateTimeline | null =
-      await this.findOneBy({
-        query: {
-          scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
-          startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
-        },
-        sort: {
-          startsAt: SortOrder.Descending,
-        },
-        props: {
-          isRoot: true,
-        },
-        select: {
-          scheduledMaintenanceStateId: true,
-          startsAt: true,
-          endsAt: true,
-        },
-      });
+    try {
+      try {
+        mutex = await Semaphore.lock({
+          key: createBy.data.scheduledMaintenanceId.toString(),
+          namespace: "ScheduledMaintenanceStateTimeline.create",
+        });
+      } catch (err) {
+        logger.error(err);
+      }
 
-    // If this is the first state, then do not notify the owner.
-    if (!stateBeforeThis) {
-      // since this is the first status, do not notify the owner.
-      createBy.data.isOwnerNotified = true;
-    }
+      if (!createBy.data.startsAt) {
+        createBy.data.startsAt = OneUptimeDate.getCurrentDate();
+      }
 
-    const stateAfterThis: ScheduledMaintenanceStateTimeline | null =
-      await this.findOneBy({
-        query: {
-          scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
-          startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
-        },
-        sort: {
-          startsAt: SortOrder.Ascending,
-        },
-        props: {
-          isRoot: true,
-        },
-        select: {
-          scheduledMaintenanceStateId: true,
-          startsAt: true,
-          endsAt: true,
-        },
-      });
+      const scheduledMaintenanceStateId: ObjectID | undefined | null =
+        createBy.data.scheduledMaintenanceStateId ||
+        createBy.data.scheduledMaintenanceState?.id;
 
-    // compute ends at. It's the start of the next status.
-    if (stateAfterThis && stateAfterThis.startsAt) {
-      createBy.data.endsAt = stateAfterThis.startsAt;
-    }
+      if (!scheduledMaintenanceStateId) {
+        throw new BadDataException("scheduledMaintenanceStateId is null");
+      }
+
+      const stateBeforeThis: ScheduledMaintenanceStateTimeline | null =
+        await this.findOneBy({
+          query: {
+            scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
+            startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
+          },
+          sort: {
+            startsAt: SortOrder.Descending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            scheduledMaintenanceStateId: true,
+            scheduledMaintenanceState: {
+              order: true,
+              name: true,
+            },
+            startsAt: true,
+            endsAt: true,
+          },
+        });
+
+      // If this is the first state, then do not notify the owner.
+      if (!stateBeforeThis) {
+        // since this is the first status, do not notify the owner.
+        createBy.data.isOwnerNotified = true;
+      }
 
-    const publicNote: string | undefined = (
-      createBy.miscDataProps as JSONObject | undefined
-    )?.["publicNote"] as string | undefined;
-
-    if (publicNote) {
-      const scheduledMaintenancePublicNote: ScheduledMaintenancePublicNote =
-        new ScheduledMaintenancePublicNote();
-      scheduledMaintenancePublicNote.scheduledMaintenanceId =
-        createBy.data.scheduledMaintenanceId;
-      scheduledMaintenancePublicNote.note = publicNote;
-      scheduledMaintenancePublicNote.postedAt = createBy.data.startsAt;
-      scheduledMaintenancePublicNote.createdAt = createBy.data.startsAt;
-      scheduledMaintenancePublicNote.projectId = createBy.data.projectId!;
-      scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated =
-        Boolean(createBy.data.shouldStatusPageSubscribersBeNotified);
-
-      // mark status page subscribers as notified for this state change because we dont want to send duplicate (two) emails one for public note and one for state change.
       if (
-        scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated
+        stateBeforeThis &&
+        stateBeforeThis.scheduledMaintenanceStateId &&
+        scheduledMaintenanceStateId
       ) {
-        createBy.data.isStatusPageSubscribersNotified = true;
+        if (
+          stateBeforeThis.scheduledMaintenanceStateId.toString() ===
+          scheduledMaintenanceStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Scheduled Maintenance state cannot be same as previous state.",
+          );
+        }
       }
 
-      await ScheduledMaintenancePublicNoteService.create({
-        data: scheduledMaintenancePublicNote,
-        props: createBy.props,
-      });
-    }
+      if (stateBeforeThis && stateBeforeThis.scheduledMaintenanceState?.order) {
+        const newScheduledMaintenanceState: ScheduledMaintenanceState | null =
+          await ScheduledMaintenanceStateService.findOneBy({
+            query: {
+              _id: scheduledMaintenanceStateId,
+            },
+            select: {
+              order: true,
+              name: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
 
-    return {
-      createBy,
-      carryForward: {
-        statusTimelineBeforeThisStatus: stateBeforeThis || null,
-        statusTimelineAfterThisStatus: stateAfterThis || null,
-        publicNote: publicNote,
-      },
-    };
+        if (
+          newScheduledMaintenanceState &&
+          newScheduledMaintenanceState.order
+        ) {
+          // check if the new scheduledMaintenance state is in order is greater than the previous state order
+          if (
+            stateBeforeThis &&
+            stateBeforeThis.scheduledMaintenanceState &&
+            stateBeforeThis.scheduledMaintenanceState.order &&
+            newScheduledMaintenanceState.order <=
+              stateBeforeThis.scheduledMaintenanceState.order
+          ) {
+            throw new BadDataException(
+              `ScheduledMaintenance cannot transition to ${newScheduledMaintenanceState.name} state from ${stateBeforeThis.scheduledMaintenanceState.name} state because ${newScheduledMaintenanceState.name} is before ${stateBeforeThis.scheduledMaintenanceState.name} in the order of scheduledMaintenance states.`,
+            );
+          }
+        }
+      }
+
+      const stateAfterThis: ScheduledMaintenanceStateTimeline | null =
+        await this.findOneBy({
+          query: {
+            scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
+            startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
+          },
+          sort: {
+            startsAt: SortOrder.Ascending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            scheduledMaintenanceStateId: true,
+            startsAt: true,
+            endsAt: true,
+          },
+        });
+
+      // compute ends at. It's the start of the next status.
+      if (stateAfterThis && stateAfterThis.startsAt) {
+        createBy.data.endsAt = stateAfterThis.startsAt;
+      }
+
+      if (
+        stateAfterThis &&
+        stateAfterThis.scheduledMaintenanceStateId &&
+        scheduledMaintenanceStateId
+      ) {
+        if (
+          stateAfterThis.scheduledMaintenanceStateId.toString() ===
+          scheduledMaintenanceStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Scheduled Maintenance state cannot be same as next state.",
+          );
+        }
+      }
+
+      const publicNote: string | undefined = (
+        createBy.miscDataProps as JSONObject | undefined
+      )?.["publicNote"] as string | undefined;
+
+      if (publicNote) {
+        const scheduledMaintenancePublicNote: ScheduledMaintenancePublicNote =
+          new ScheduledMaintenancePublicNote();
+        scheduledMaintenancePublicNote.scheduledMaintenanceId =
+          createBy.data.scheduledMaintenanceId;
+        scheduledMaintenancePublicNote.note = publicNote;
+        scheduledMaintenancePublicNote.postedAt = createBy.data.startsAt;
+        scheduledMaintenancePublicNote.createdAt = createBy.data.startsAt;
+        scheduledMaintenancePublicNote.projectId = createBy.data.projectId!;
+        scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated =
+          Boolean(createBy.data.shouldStatusPageSubscribersBeNotified);
+
+        // mark status page subscribers as notified for this state change because we dont want to send duplicate (two) emails one for public note and one for state change.
+        if (
+          scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated
+        ) {
+          createBy.data.isStatusPageSubscribersNotified = true;
+        }
+
+        await ScheduledMaintenancePublicNoteService.create({
+          data: scheduledMaintenancePublicNote,
+          props: createBy.props,
+        });
+      }
+
+      return {
+        createBy,
+        carryForward: {
+          statusTimelineBeforeThisStatus: stateBeforeThis || null,
+          statusTimelineAfterThisStatus: stateAfterThis || null,
+          publicNote: publicNote,
+          mutex: mutex,
+        },
+      };
+    } catch (error) {
+      // release the mutex if it was acquired.
+      if (mutex) {
+        try {
+          await Semaphore.release(mutex);
+        } catch (err) {
+          logger.error(err);
+        }
+      }
+
+      throw error;
+    }
   }
 
   @CaptureSpan()
@@ -190,6 +292,8 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
     onCreate: OnCreate<ScheduledMaintenanceStateTimeline>,
     createdItem: ScheduledMaintenanceStateTimeline,
   ): Promise<ScheduledMaintenanceStateTimeline> {
+    const mutex: SemaphoreMutex | null = onCreate.carryForward.mutex;
+
     if (!createdItem.scheduledMaintenanceId) {
       throw new BadDataException("scheduledMaintenanceId is null");
     }
@@ -266,6 +370,14 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
       });
     }
 
+    if (mutex) {
+      try {
+        await Semaphore.release(mutex);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
     const scheduledMaintenanceState: ScheduledMaintenanceState | null =
       await ScheduledMaintenanceStateService.findOneBy({
         query: {

package/Server/Utils/Monitor/MonitorResource.ts

@@ -44,7 +44,6 @@ import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import MonitorIncident from "./MonitorIncident";
 import MonitorAlert from "./MonitorAlert";
 import MonitorStatusTimelineUtil from "./MonitorStatusTimeline";
-// import Semaphore, { SemaphoreMutex } from "../../Infrastructure/Semaphore";
 import Metric, {
   MetricPointType,
   ServiceType,

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

@@ -26,6 +26,7 @@ import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import Semaphore from "../Infrastructure/Semaphore";
 export class Service extends DatabaseService {
     constructor() {
         super(AlertStateTimeline);
@@ -52,105 +53,176 @@ export class Service extends DatabaseService {
         return resolvedState.id;
     }
     async onBeforeCreate(createBy) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (!createBy.data.alertId) {
             throw new BadDataException("alertId is null");
         }
-        if (!createBy.data.startsAt) {
-            createBy.data.startsAt = OneUptimeDate.getCurrentDate();
-        }
-        if ((createBy.data.createdByUserId ||
-            createBy.data.createdByUser ||
-            createBy.props.userId) &&
-            !createBy.data.rootCause) {
-            let userId = createBy.data.createdByUserId;
-            if (createBy.props.userId) {
-                userId = createBy.props.userId;
+        let mutex = null;
+        try {
+            if (!createBy.data.startsAt) {
+                createBy.data.startsAt = OneUptimeDate.getCurrentDate();
             }
-            if (createBy.data.createdByUser && createBy.data.createdByUser.id) {
-                userId = createBy.data.createdByUser.id;
+            try {
+                mutex = await Semaphore.lock({
+                    key: createBy.data.alertId.toString(),
+                    namespace: "AlertStateTimeline.create",
+                });
             }
-            if (userId) {
-                createBy.data.rootCause = `Alert state created by ${await UserService.getUserMarkdownString({
-                    userId: userId,
-                    projectId: createBy.data.projectId || createBy.props.tenantId,
-                })}`;
+            catch (err) {
+                logger.error(err);
             }
-        }
-        const stateBeforeThis = await this.findOneBy({
-            query: {
-                alertId: createBy.data.alertId,
-                startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
-            },
-            sort: {
-                startsAt: SortOrder.Descending,
-            },
-            props: {
-                isRoot: true,
-            },
-            select: {
-                alertStateId: true,
-                startsAt: true,
-                endsAt: true,
-            },
-        });
-        logger.debug("State Before this");
-        logger.debug(stateBeforeThis);
-        // If this is the first state, then do not notify the owner.
-        if (!stateBeforeThis) {
-            // since this is the first status, do not notify the owner.
-            createBy.data.isOwnerNotified = true;
-        }
-        const stateAfterThis = await this.findOneBy({
-            query: {
-                alertId: createBy.data.alertId,
-                startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
-            },
-            sort: {
-                startsAt: SortOrder.Ascending,
-            },
-            props: {
-                isRoot: true,
-            },
-            select: {
-                alertStateId: true,
-                startsAt: true,
-                endsAt: true,
-            },
-        });
-        // compute ends at. It's the start of the next status.
-        if (stateAfterThis && stateAfterThis.startsAt) {
-            createBy.data.endsAt = stateAfterThis.startsAt;
-        }
-        logger.debug("State After this");
-        logger.debug(stateAfterThis);
-        const internalNote = (_a = createBy.miscDataProps) === null || _a === void 0 ? void 0 : _a["internalNote"];
-        if (internalNote) {
-            const alertNote = new AlertInternalNote();
-            alertNote.alertId = createBy.data.alertId;
-            alertNote.note = internalNote;
-            alertNote.createdAt = createBy.data.startsAt;
-            alertNote.projectId = createBy.data.projectId;
-            await AlertInternalNoteService.create({
-                data: alertNote,
-                props: createBy.props,
+            if ((createBy.data.createdByUserId ||
+                createBy.data.createdByUser ||
+                createBy.props.userId) &&
+                !createBy.data.rootCause) {
+                let userId = createBy.data.createdByUserId;
+                if (createBy.props.userId) {
+                    userId = createBy.props.userId;
+                }
+                if (createBy.data.createdByUser && createBy.data.createdByUser.id) {
+                    userId = createBy.data.createdByUser.id;
+                }
+                if (userId) {
+                    createBy.data.rootCause = `Alert state created by ${await UserService.getUserMarkdownString({
+                        userId: userId,
+                        projectId: createBy.data.projectId || createBy.props.tenantId,
+                    })}`;
+                }
+            }
+            const alertStateId = createBy.data.alertStateId || ((_a = createBy.data.alertState) === null || _a === void 0 ? void 0 : _a.id);
+            if (!alertStateId) {
+                throw new BadDataException("alertStateId is null");
+            }
+            const stateBeforeThis = await this.findOneBy({
+                query: {
+                    alertId: createBy.data.alertId,
+                    startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
+                },
+                sort: {
+                    startsAt: SortOrder.Descending,
+                },
+                props: {
+                    isRoot: true,
+                },
+                select: {
+                    alertStateId: true,
+                    alertState: {
+                        order: true,
+                        name: true,
+                    },
+                    startsAt: true,
+                    endsAt: true,
+                },
+            });
+            logger.debug("State Before this");
+            logger.debug(stateBeforeThis);
+            // If this is the first state, then do not notify the owner.
+            if (!stateBeforeThis) {
+                // since this is the first status, do not notify the owner.
+                createBy.data.isOwnerNotified = true;
+            }
+            // check if this new state and the previous state are same.
+            // if yes, then throw bad data exception.
+            if (stateBeforeThis && stateBeforeThis.alertStateId && alertStateId) {
+                if (stateBeforeThis.alertStateId.toString() === alertStateId.toString()) {
+                    throw new BadDataException("Alert state cannot be same as previous state.");
+                }
+            }
+            if (stateBeforeThis && ((_b = stateBeforeThis.alertState) === null || _b === void 0 ? void 0 : _b.order)) {
+                const newAlertState = await AlertStateService.findOneBy({
+                    query: {
+                        _id: alertStateId,
+                    },
+                    select: {
+                        order: true,
+                        name: true,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (newAlertState && newAlertState.order) {
+                    // check if the new alert state is in order is greater than the previous state order
+                    if (stateBeforeThis &&
+                        stateBeforeThis.alertState &&
+                        stateBeforeThis.alertState.order &&
+                        newAlertState.order <= stateBeforeThis.alertState.order) {
+                        throw new BadDataException(`Alert cannot transition to ${newAlertState.name} state from ${stateBeforeThis.alertState.name} state because ${newAlertState.name} is before ${stateBeforeThis.alertState.name} in the order of alert states.`);
+                    }
+                }
+            }
+            const stateAfterThis = await this.findOneBy({
+                query: {
+                    alertId: createBy.data.alertId,
+                    startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
+                },
+                sort: {
+                    startsAt: SortOrder.Ascending,
+                },
+                props: {
+                    isRoot: true,
+                },
+                select: {
+                    alertStateId: true,
+                    startsAt: true,
+                    endsAt: true,
+                },
             });
+            // compute ends at. It's the start of the next status.
+            if (stateAfterThis && stateAfterThis.startsAt) {
+                createBy.data.endsAt = stateAfterThis.startsAt;
+            }
+            // check if this new state and the previous state are same.
+            // if yes, then throw bad data exception.
+            if (stateAfterThis && stateAfterThis.alertStateId && alertStateId) {
+                if (stateAfterThis.alertStateId.toString() === alertStateId.toString()) {
+                    throw new BadDataException("Alert state cannot be same as next state.");
+                }
+            }
+            logger.debug("State After this");
+            logger.debug(stateAfterThis);
+            const internalNote = (_c = createBy.miscDataProps) === null || _c === void 0 ? void 0 : _c["internalNote"];
+            if (internalNote) {
+                const alertNote = new AlertInternalNote();
+                alertNote.alertId = createBy.data.alertId;
+                alertNote.note = internalNote;
+                alertNote.createdAt = createBy.data.startsAt;
+                alertNote.projectId = createBy.data.projectId;
+                await AlertInternalNoteService.create({
+                    data: alertNote,
+                    props: createBy.props,
+                });
+            }
+            const privateNote = (_d = createBy.miscDataProps) === null || _d === void 0 ? void 0 : _d["privateNote"];
+            return {
+                createBy,
+                carryForward: {
+                    statusTimelineBeforeThisStatus: stateBeforeThis || null,
+                    statusTimelineAfterThisStatus: stateAfterThis || null,
+                    privateNote: privateNote,
+                    mutex: mutex,
+                },
+            };
+        }
+        catch (error) {
+            // release the mutex if it was acquired.
+            if (mutex) {
+                try {
+                    await Semaphore.release(mutex);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
+            }
+            throw error;
         }
-        const privateNote = (_b = createBy.miscDataProps) === null || _b === void 0 ? void 0 : _b["privateNote"];
-        return {
-            createBy,
-            carryForward: {
-                statusTimelineBeforeThisStatus: stateBeforeThis || null,
-                statusTimelineAfterThisStatus: stateAfterThis || null,
-                privateNote: privateNote,
-            },
-        };
     }
     async onCreateSuccess(onCreate, createdItem) {
         var _a;
         if (!createdItem.alertId) {
             throw new BadDataException("alertId is null");
         }
+        const mutex = onCreate.carryForward.mutex;
         if (!createdItem.alertStateId) {
             throw new BadDataException("alertStateId is null");
         }
@@ -215,6 +287,14 @@ export class Service extends DatabaseService {
                 props: onCreate.createBy.props,
             });
         }
+        if (mutex) {
+            try {
+                await Semaphore.release(mutex);
+            }
+            catch (err) {
+                logger.error(err);
+            }
+        }
         const alertState = await AlertStateService.findOneBy({
             query: {
                 _id: createdItem.alertStateId.toString(),