@oneuptime/common 7.0.4137 → 7.0.4144

package/Server/Services/AlertStateTimelineService.ts

@@ -23,6 +23,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, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 
 export class Service extends DatabaseService<AlertStateTimeline> {
   public constructor() {
@@ -64,118 +65,210 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       throw new BadDataException("alertId is null");
     }
 
-    if (!createBy.data.startsAt) {
-      createBy.data.startsAt = OneUptimeDate.getCurrentDate();
-    }
+    let mutex: SemaphoreMutex | null = null;
 
-    if (
-      (createBy.data.createdByUserId ||
-        createBy.data.createdByUser ||
-        createBy.props.userId) &&
-      !createBy.data.rootCause
-    ) {
-      let userId: ObjectID | undefined = createBy.data.createdByUserId;
+    try {
+      if (!createBy.data.startsAt) {
+        createBy.data.startsAt = OneUptimeDate.getCurrentDate();
+      }
 
-      if (createBy.props.userId) {
-        userId = createBy.props.userId;
+      try {
+        mutex = await Semaphore.lock({
+          key: createBy.data.alertId.toString(),
+          namespace: "AlertStateTimeline.create",
+        });
+      } catch (err) {
+        logger.error(err);
       }
 
-      if (createBy.data.createdByUser && createBy.data.createdByUser.id) {
-        userId = createBy.data.createdByUser.id;
+      if (
+        (createBy.data.createdByUserId ||
+          createBy.data.createdByUser ||
+          createBy.props.userId) &&
+        !createBy.data.rootCause
+      ) {
+        let userId: ObjectID | undefined = 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!,
+            },
+          )}`;
+        }
       }
 
-      if (userId) {
-        createBy.data.rootCause = `Alert state created by ${await UserService.getUserMarkdownString(
-          {
-            userId: userId!,
-            projectId: createBy.data.projectId || createBy.props.tenantId!,
+      const alertStateId: ObjectID | undefined | null =
+        createBy.data.alertStateId || createBy.data.alertState?.id;
+
+      if (!alertStateId) {
+        throw new BadDataException("alertStateId is null");
+      }
+
+      const stateBeforeThis: AlertStateTimeline | null = 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;
       }
-    }
 
-    const stateBeforeThis: AlertStateTimeline | null = 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,
-      },
-    });
+      // check if this new state and the previous state are same.
+      // if yes, then throw bad data exception.
 
-    logger.debug("State Before this");
-    logger.debug(stateBeforeThis);
+      if (stateBeforeThis && stateBeforeThis.alertStateId && alertStateId) {
+        if (
+          stateBeforeThis.alertStateId.toString() === alertStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Alert state cannot be same as previous state.",
+          );
+        }
+      }
 
-    // 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 (stateBeforeThis && stateBeforeThis.alertState?.order) {
+        const newAlertState: AlertState | null =
+          await AlertStateService.findOneBy({
+            query: {
+              _id: alertStateId,
+            },
+            select: {
+              order: true,
+              name: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
 
-    const stateAfterThis: AlertStateTimeline | null = 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,
-      },
-    });
+        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.`,
+            );
+          }
+        }
+      }
 
-    // compute ends at. It's the start of the next status.
-    if (stateAfterThis && stateAfterThis.startsAt) {
-      createBy.data.endsAt = stateAfterThis.startsAt;
-    }
+      const stateAfterThis: AlertStateTimeline | null = 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,
+        },
+      });
 
-    logger.debug("State After this");
-    logger.debug(stateAfterThis);
+      // compute ends at. It's the start of the next status.
+      if (stateAfterThis && stateAfterThis.startsAt) {
+        createBy.data.endsAt = stateAfterThis.startsAt;
+      }
 
-    const internalNote: string | undefined = (
-      createBy.miscDataProps as JSONObject | undefined
-    )?.["internalNote"] as string | undefined;
+      // check if this new state and the previous state are same.
+      // if yes, then throw bad data exception.
 
-    if (internalNote) {
-      const alertNote: AlertInternalNote = new AlertInternalNote();
-      alertNote.alertId = createBy.data.alertId;
-      alertNote.note = internalNote;
-      alertNote.createdAt = createBy.data.startsAt;
-      alertNote.projectId = createBy.data.projectId!;
+      if (stateAfterThis && stateAfterThis.alertStateId && alertStateId) {
+        if (
+          stateAfterThis.alertStateId.toString() === alertStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Alert state cannot be same as next state.",
+          );
+        }
+      }
 
-      await AlertInternalNoteService.create({
-        data: alertNote,
-        props: createBy.props,
-      });
-    }
+      logger.debug("State After this");
+      logger.debug(stateAfterThis);
 
-    const privateNote: string | undefined = (
-      createBy.miscDataProps as JSONObject | undefined
-    )?.["privateNote"] as string | undefined;
+      const internalNote: string | undefined = (
+        createBy.miscDataProps as JSONObject | undefined
+      )?.["internalNote"] as string | undefined;
 
-    return {
-      createBy,
-      carryForward: {
-        statusTimelineBeforeThisStatus: stateBeforeThis || null,
-        statusTimelineAfterThisStatus: stateAfterThis || null,
-        privateNote: privateNote,
-      },
-    };
+      if (internalNote) {
+        const alertNote: AlertInternalNote = 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: string | undefined = (
+        createBy.miscDataProps as JSONObject | undefined
+      )?.["privateNote"] as string | undefined;
+
+      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;
+    }
   }
 
   @CaptureSpan()
@@ -187,6 +280,8 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       throw new BadDataException("alertId is null");
     }
 
+    const mutex: SemaphoreMutex | null = onCreate.carryForward.mutex;
+
     if (!createdItem.alertStateId) {
       throw new BadDataException("alertStateId is null");
     }
@@ -256,6 +351,14 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       });
     }
 
+    if (mutex) {
+      try {
+        await Semaphore.release(mutex);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
     const alertState: AlertState | null = await AlertStateService.findOneBy({
       query: {
         _id: createdItem.alertStateId.toString()!,

package/Server/Services/IncidentStateTimelineService.ts

@@ -24,6 +24,7 @@ import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed"
 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<IncidentStateTimeline> {
   public constructor() {
@@ -62,112 +63,214 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
   protected override async onBeforeCreate(
     createBy: CreateBy<IncidentStateTimeline>,
   ): Promise<OnCreate<IncidentStateTimeline>> {
-    if (!createBy.data.incidentId) {
-      throw new BadDataException("incidentId is null");
-    }
+    let mutex: SemaphoreMutex | null = null;
 
-    if (!createBy.data.startsAt) {
-      createBy.data.startsAt = OneUptimeDate.getCurrentDate();
-    }
+    try {
+      if (!createBy.data.incidentId) {
+        throw new BadDataException("incidentId is null");
+      }
 
-    if (
-      (createBy.data.createdByUserId ||
-        createBy.data.createdByUser ||
-        createBy.props.userId) &&
-      !createBy.data.rootCause
-    ) {
-      let userId: ObjectID | undefined = createBy.data.createdByUserId;
+      try {
+        mutex = await Semaphore.lock({
+          key: createBy.data.incidentId.toString(),
+          namespace: "IncidentStateTimeline.create",
+        });
+      } catch (err) {
+        logger.error(err);
+      }
 
-      if (createBy.props.userId) {
-        userId = createBy.props.userId;
+      if (!createBy.data.startsAt) {
+        createBy.data.startsAt = OneUptimeDate.getCurrentDate();
       }
 
-      if (createBy.data.createdByUser && createBy.data.createdByUser.id) {
-        userId = createBy.data.createdByUser.id;
+      if (
+        (createBy.data.createdByUserId ||
+          createBy.data.createdByUser ||
+          createBy.props.userId) &&
+        !createBy.data.rootCause
+      ) {
+        let userId: ObjectID | undefined = 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 = `Incident state created by ${await UserService.getUserMarkdownString(
+            {
+              userId: userId!,
+              projectId: createBy.data.projectId || createBy.props.tenantId!,
+            },
+          )}`;
+        }
       }
 
-      if (userId) {
-        createBy.data.rootCause = `Incident state created by ${await UserService.getUserMarkdownString(
-          {
-            userId: userId!,
-            projectId: createBy.data.projectId || createBy.props.tenantId!,
+      const incidentStateId: ObjectID | undefined | null =
+        createBy.data.incidentStateId || createBy.data.incidentState?.id;
+
+      if (!incidentStateId) {
+        throw new BadDataException("incidentStateId is null");
+      }
+
+      const stateBeforeThis: IncidentStateTimeline | null =
+        await this.findOneBy({
+          query: {
+            incidentId: createBy.data.incidentId,
+            startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
+          },
+          sort: {
+            startsAt: SortOrder.Descending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            incidentStateId: true,
+            incidentState: {
+              _id: true,
+              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;
       }
-    }
 
-    const stateBeforeThis: IncidentStateTimeline | null = await this.findOneBy({
-      query: {
-        incidentId: createBy.data.incidentId,
-        startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
-      },
-      sort: {
-        startsAt: SortOrder.Descending,
-      },
-      props: {
-        isRoot: true,
-      },
-      select: {
-        incidentStateId: true,
-        startsAt: true,
-        endsAt: true,
-      },
-    });
+      // check if this new state and the previous state are same.
+      // if yes, then throw bad data exception.
+
+      if (
+        stateBeforeThis &&
+        stateBeforeThis.incidentStateId &&
+        incidentStateId
+      ) {
+        if (
+          stateBeforeThis.incidentStateId.toString() ===
+          incidentStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Incident state cannot be same as previous state.",
+          );
+        }
+      }
+
+      if (stateBeforeThis && stateBeforeThis.incidentState?.order) {
+        const newIncidentState: IncidentState | null =
+          await IncidentStateService.findOneBy({
+            query: {
+              _id: incidentStateId,
+            },
+            select: {
+              order: true,
+              name: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
 
-    logger.debug("State Before this");
-    logger.debug(stateBeforeThis);
+        if (newIncidentState && newIncidentState.order) {
+          // check if the new incident state is in order is greater than the previous state order
+          if (
+            stateBeforeThis &&
+            stateBeforeThis.incidentState &&
+            stateBeforeThis.incidentState.order &&
+            newIncidentState.order <= stateBeforeThis.incidentState.order
+          ) {
+            throw new BadDataException(
+              `Incident cannot transition to ${newIncidentState.name} state from ${stateBeforeThis.incidentState.name} state because ${newIncidentState.name} is before ${stateBeforeThis.incidentState.name} in the order of incident states.`,
+            );
+          }
+        }
+      }
 
-    // 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: IncidentStateTimeline | null = await this.findOneBy(
+        {
+          query: {
+            incidentId: createBy.data.incidentId,
+            startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
+          },
+          sort: {
+            startsAt: SortOrder.Ascending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            incidentStateId: true,
+            startsAt: true,
+            endsAt: true,
+          },
+        },
+      );
 
-    const stateAfterThis: IncidentStateTimeline | null = await this.findOneBy({
-      query: {
-        incidentId: createBy.data.incidentId,
-        startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
-      },
-      sort: {
-        startsAt: SortOrder.Ascending,
-      },
-      props: {
-        isRoot: true,
-      },
-      select: {
-        incidentStateId: 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;
+      }
 
-    // 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.incidentStateId && incidentStateId) {
+        if (
+          stateAfterThis.incidentStateId.toString() ===
+          incidentStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Incident state cannot be same as next state.",
+          );
+        }
+      }
 
-    logger.debug("State After this");
-    logger.debug(stateAfterThis);
+      logger.debug("State After this");
+      logger.debug(stateAfterThis);
 
-    const publicNote: string | undefined = (
-      createBy.miscDataProps as JSONObject | undefined
-    )?.["publicNote"] as string | undefined;
+      const publicNote: string | undefined = (
+        createBy.miscDataProps as JSONObject | undefined
+      )?.["publicNote"] as string | undefined;
 
-    if (publicNote) {
-      // 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 (createBy.data.shouldStatusPageSubscribersBeNotified) {
-        createBy.data.isStatusPageSubscribersNotified = true;
+      if (publicNote) {
+        // 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 (createBy.data.shouldStatusPageSubscribersBeNotified) {
+          createBy.data.isStatusPageSubscribersNotified = true;
+        }
       }
-    }
 
-    return {
-      createBy,
-      carryForward: {
-        statusTimelineBeforeThisStatus: stateBeforeThis || null,
-        statusTimelineAfterThisStatus: stateAfterThis || null,
-        publicNote: publicNote,
-      },
-    };
+      return {
+        createBy,
+        carryForward: {
+          statusTimelineBeforeThisStatus: stateBeforeThis || null,
+          statusTimelineAfterThisStatus: stateAfterThis || null,
+          publicNote: publicNote,
+          mutex: mutex,
+        },
+      };
+    } catch (err) {
+      // release the mutex if it was acquired.
+      if (mutex) {
+        try {
+          await Semaphore.release(mutex);
+        } catch (err) {
+          logger.error(err);
+        }
+      }
+
+      throw err;
+    }
   }
 
   @CaptureSpan()
@@ -175,6 +278,8 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
     onCreate: OnCreate<IncidentStateTimeline>,
     createdItem: IncidentStateTimeline,
   ): Promise<IncidentStateTimeline> {
+    const mutex: SemaphoreMutex | null = onCreate.carryForward.mutex;
+
     if (!createdItem.incidentId) {
       throw new BadDataException("incidentId is null");
     }
@@ -267,6 +372,14 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
         },
       });
 
+    if (mutex) {
+      try {
+        await Semaphore.release(mutex);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
     const stateName: string = incidentState?.name || "";
     let stateEmoji: string = "➡️";