@oneuptime/common 7.0.5096 → 7.0.5108

package/Server/Services/AlertService.ts

@@ -273,109 +273,88 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("currentAlertStateId is required");
     }
 
-    // Get alert data for feed creation
-    const alert: Model | null = await this.findOneById({
-      id: createdItem.id,
-      select: {
-        projectId: true,
-        alertNumber: true,
-        title: true,
-        description: true,
-        alertSeverity: {
-          name: true,
-        },
-        rootCause: true,
-        remediationNotes: true,
-        currentAlertState: {
-          name: true,
-        },
-        labels: {
-          name: true,
-        },
-        monitor: {
-          name: true,
-          _id: true,
-        },
-      },
-      props: {
-        isRoot: true,
-      },
-    });
-
-    if (!alert) {
-      throw new BadDataException("Alert not found");
-    }
-
-    // Execute core operations in parallel first
-    const coreOperations: Array<Promise<any>> = [];
-
-    // Create feed item asynchronously
-    coreOperations.push(this.createAlertFeedAsync(alert, createdItem));
-
-    // Handle state change asynchronously
-    coreOperations.push(this.handleAlertStateChangeAsync(createdItem));
-
-    // Handle owner assignment asynchronously
-    if (
-      onCreate.createBy.miscDataProps &&
-      (onCreate.createBy.miscDataProps["ownerTeams"] ||
-        onCreate.createBy.miscDataProps["ownerUsers"])
-    ) {
-      coreOperations.push(
-        this.addOwners(
-          createdItem.projectId,
-          createdItem.id,
-          (onCreate.createBy.miscDataProps["ownerUsers"] as Array<ObjectID>) ||
-            [],
-          (onCreate.createBy.miscDataProps["ownerTeams"] as Array<ObjectID>) ||
-            [],
-          false,
-          onCreate.createBy.props,
-        ),
-      );
-    }
-
-    // Execute core operations in parallel with error handling
-    Promise.allSettled(coreOperations)
-      .then((coreResults: any[]) => {
-        // Log any errors from core operations
-        coreResults.forEach((result: any, index: number) => {
-          if (result.status === "rejected") {
+    // Execute operations sequentially with error handling
+    Promise.resolve()
+      .then(async () => {
+        if (createdItem.projectId && createdItem.id) {
+          try {
+            return await this.handleAlertWorkspaceOperationsAsync(createdItem);
+          } catch (error) {
             logger.error(
-              `Core operation ${index} failed in AlertService.onCreateSuccess: ${result.reason}`,
+              `Workspace operations failed in AlertService.onCreateSuccess: ${error}`,
             );
+            return Promise.resolve();
           }
-        });
-
-        // Handle on-call duty policies asynchronously
+        }
+        return Promise.resolve();
+      })
+      .then(async () => {
+        try {
+          return await this.createAlertFeedAsync(createdItem.id!);
+        } catch (error) {
+          logger.error(
+            `Create alert feed failed in AlertService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve(); // Continue chain even on error
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.handleAlertStateChangeAsync(createdItem);
+        } catch (error) {
+          logger.error(
+            `Handle alert state change failed in AlertService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve(); // Continue chain even on error
+        }
+      })
+      .then(async () => {
+        try {
+          if (
+            onCreate.createBy.miscDataProps &&
+            (onCreate.createBy.miscDataProps["ownerTeams"] ||
+              onCreate.createBy.miscDataProps["ownerUsers"])
+          ) {
+            return await this.addOwners(
+              createdItem.projectId!,
+              createdItem.id!,
+              (onCreate.createBy.miscDataProps![
+                "ownerUsers"
+              ] as Array<ObjectID>) || [],
+              (onCreate.createBy.miscDataProps![
+                "ownerTeams"
+              ] as Array<ObjectID>) || [],
+              false,
+              onCreate.createBy.props,
+            );
+          }
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            `Add owners failed in AlertService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve(); // Continue chain even on error
+        }
+      })
+      .then(async () => {
         if (
           createdItem.onCallDutyPolicies?.length &&
           createdItem.onCallDutyPolicies?.length > 0
         ) {
-          this.executeAlertOnCallDutyPoliciesAsync(createdItem).catch(
-            (error: Error) => {
-              logger.error(
-                `On-call duty policy execution failed in AlertService.onCreateSuccess: ${error}`,
-              );
-            },
-          );
-        }
-
-        // Handle workspace operations after core operations complete
-        if (createdItem.projectId && createdItem.id) {
-          // Run workspace operations in background without blocking response
-          this.handleAlertWorkspaceOperationsAsync(createdItem).catch(
-            (error: Error) => {
-              logger.error(
-                `Workspace operations failed in AlertService.onCreateSuccess: ${error}`,
-              );
-            },
-          );
+          try {
+            return await this.executeAlertOnCallDutyPoliciesAsync(createdItem);
+          } catch (error) {
+            logger.error(
+              `On-call duty policy execution failed in AlertService.onCreateSuccess: ${error}`,
+            );
+            return Promise.resolve();
+          }
         }
+        return Promise.resolve();
       })
       .catch((error: Error) => {
         logger.error(
-          `Critical error in AlertService core operations: ${error}`,
+          `Critical error in AlertService sequential operations: ${error}`,
         );
       });
 
@@ -426,19 +405,55 @@ export class Service extends DatabaseService<Model> {
   }
 
   @CaptureSpan()
-  private async createAlertFeedAsync(
-    alert: Model,
-    createdItem: Model,
-  ): Promise<void> {
+  private async createAlertFeedAsync(alertId: ObjectID): Promise<void> {
     try {
+      // Get alert data for feed creation
+      const alert: Model | null = await this.findOneById({
+        id: alertId,
+        select: {
+          projectId: true,
+          alertNumber: true,
+          title: true,
+          description: true,
+          alertSeverity: {
+            name: true,
+          },
+          rootCause: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+            name: true,
+            email: true,
+          },
+          remediationNotes: true,
+          currentAlertState: {
+            name: true,
+          },
+          labels: {
+            name: true,
+          },
+          monitor: {
+            name: true,
+            _id: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!alert) {
+        throw new BadDataException("Alert not found");
+      }
+
       const createdByUserId: ObjectID | undefined | null =
-        createdItem.createdByUserId || createdItem.createdByUser?.id;
+        alert.createdByUserId || alert.createdByUser?.id;
 
-      let feedInfoInMarkdown: string = `#### 🚨 Alert ${createdItem.alertNumber?.toString()} Created: 
+      let feedInfoInMarkdown: string = `#### 🚨 Alert ${alert.alertNumber?.toString()} Created: 
            
-**${createdItem.title || "No title provided."}**:
+**${alert.title || "No title provided."}**:
      
-${createdItem.description || "No description provided."}
+${alert.description || "No description provided."}
      
 `;
 
@@ -454,25 +469,25 @@ ${createdItem.description || "No description provided."}
         feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
 
         const monitor: Monitor = alert.monitor;
-        feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(createdItem.projectId!, monitor.id!)).toString()})\n`;
+        feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(alert.projectId!, monitor.id!)).toString()})\n`;
 
         feedInfoInMarkdown += `\n\n`;
       }
 
-      if (createdItem.rootCause) {
+      if (alert.rootCause) {
         feedInfoInMarkdown += `\n
 📄 **Root Cause**:
      
-${createdItem.rootCause || "No root cause provided."}
+${alert.rootCause || "No root cause provided."}
      
 `;
       }
 
-      if (createdItem.remediationNotes) {
+      if (alert.remediationNotes) {
         feedInfoInMarkdown += `\n 
 🎯 **Remediation Notes**:
      
-${createdItem.remediationNotes || "No remediation notes provided."}
+${alert.remediationNotes || "No remediation notes provided."}
      
      
      `;
@@ -480,13 +495,13 @@ ${createdItem.remediationNotes || "No remediation notes provided."}
 
       const alertCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
         await AlertWorkspaceMessages.getAlertCreateMessageBlocks({
-          alertId: createdItem.id!,
-          projectId: createdItem.projectId!,
+          alertId: alert.id!,
+          projectId: alert.projectId!,
         });
 
       await AlertFeedService.createAlertFeedItem({
-        alertId: createdItem.id!,
-        projectId: createdItem.projectId!,
+        alertId: alert.id!,
+        projectId: alert.projectId!,
         alertFeedEventType: AlertFeedEventType.AlertCreated,
         displayColor: Red500,
         feedInfoInMarkdown: feedInfoInMarkdown,

package/Server/Services/IncidentService.ts

@@ -597,6 +597,12 @@ export class Service extends DatabaseService<Model> {
           name: true,
         },
         rootCause: true,
+        createdByUserId: true,
+        createdByUser: {
+          _id: true,
+          name: true,
+          email: true,
+        },
         remediationNotes: true,
         currentIncidentState: {
           name: true,
@@ -618,90 +624,121 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("Incident not found");
     }
 
-    // Execute core operations in parallel first
-    const coreOperations: Array<Promise<any>> = [];
-
-    // Create feed item asynchronously
-    coreOperations.push(this.createIncidentFeedAsync(incident, createdItem));
-
-    // Handle state change asynchronously
-    coreOperations.push(this.handleIncidentStateChangeAsync(createdItem));
-
-    // Handle owner assignment asynchronously
-    if (
-      onCreate.createBy.miscDataProps &&
-      (onCreate.createBy.miscDataProps["ownerTeams"] ||
-        onCreate.createBy.miscDataProps["ownerUsers"])
-    ) {
-      coreOperations.push(
-        this.addOwners(
-          createdItem.projectId,
-          createdItem.id,
-          (onCreate.createBy.miscDataProps["ownerUsers"] as Array<ObjectID>) ||
-            [],
-          (onCreate.createBy.miscDataProps["ownerTeams"] as Array<ObjectID>) ||
-            [],
-          false,
-          onCreate.createBy.props,
-        ),
-      );
-    }
-
-    // Handle monitor status change and active monitoring asynchronously
-    if (createdItem.changeMonitorStatusToId && createdItem.projectId) {
-      coreOperations.push(
-        this.handleMonitorStatusChangeAsync(createdItem, onCreate),
-      );
-    }
-
-    coreOperations.push(
-      this.disableActiveMonitoringIfManualIncident(createdItem.id!),
-    );
-
     // Release mutex immediately
     this.releaseMutexAsync(onCreate, createdItem.projectId!);
 
-    // Execute core operations in parallel with error handling
-    Promise.allSettled(coreOperations)
-      .then((coreResults: any[]) => {
-        // Log any errors from core operations
-        coreResults.forEach((result: any, index: number) => {
-          if (result.status === "rejected") {
-            logger.error(
-              `Core operation ${index} failed in IncidentService.onCreateSuccess: ${result.reason}`,
+    // Execute operations sequentially with error handling
+    Promise.resolve()
+      .then(async () => {
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            return await this.handleIncidentWorkspaceOperationsAsync(
+              createdItem,
             );
           }
-        });
-
-        // Handle on-call duty policies asynchronously
-        if (
-          createdItem.onCallDutyPolicies?.length &&
-          createdItem.onCallDutyPolicies?.length > 0
-        ) {
-          this.executeOnCallDutyPoliciesAsync(createdItem).catch(
-            (error: Error) => {
-              logger.error(
-                `On-call duty policy execution failed in IncidentService.onCreateSuccess: ${error}`,
-              );
-            },
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            `Workspace operations failed in IncidentService.onCreateSuccess: ${error}`,
           );
+          return Promise.resolve();
         }
-
-        // Handle workspace operations after core operations complete
-        if (createdItem.projectId && createdItem.id) {
-          // Run workspace operations in background without blocking response
-          this.handleIncidentWorkspaceOperationsAsync(createdItem).catch(
-            (error: Error) => {
-              logger.error(
-                `Workspace operations failed in IncidentService.onCreateSuccess: ${error}`,
-              );
-            },
+      })
+      .then(async () => {
+        try {
+          return await this.createIncidentFeedAsync(incident);
+        } catch (error) {
+          logger.error(
+            `Create incident feed failed in IncidentService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.handleIncidentStateChangeAsync(createdItem);
+        } catch (error) {
+          logger.error(
+            `Handle incident state change failed in IncidentService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          if (
+            onCreate.createBy.miscDataProps &&
+            (onCreate.createBy.miscDataProps["ownerTeams"] ||
+              onCreate.createBy.miscDataProps["ownerUsers"])
+          ) {
+            return await this.addOwners(
+              createdItem.projectId!,
+              createdItem.id!,
+              (onCreate.createBy.miscDataProps[
+                "ownerUsers"
+              ] as Array<ObjectID>) || [],
+              (onCreate.createBy.miscDataProps[
+                "ownerTeams"
+              ] as Array<ObjectID>) || [],
+              false,
+              onCreate.createBy.props,
+            );
+          }
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            `Add owners failed in IncidentService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          if (createdItem.changeMonitorStatusToId && createdItem.projectId) {
+            return await this.handleMonitorStatusChangeAsync(
+              createdItem,
+              onCreate,
+            );
+          }
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            `Monitor status change failed in IncidentService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.disableActiveMonitoringIfManualIncident(
+            createdItem.id!,
+          );
+        } catch (error) {
+          logger.error(
+            `Disable active monitoring failed in IncidentService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          if (
+            createdItem.onCallDutyPolicies?.length &&
+            createdItem.onCallDutyPolicies?.length > 0
+          ) {
+            return await this.executeOnCallDutyPoliciesAsync(createdItem);
+          }
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            `On-call duty policy execution failed in IncidentService.onCreateSuccess: ${error}`,
           );
+          return Promise.resolve();
         }
       })
       .catch((error: Error) => {
         logger.error(
-          `Critical error in IncidentService core operations: ${error}`,
+          `Critical error in IncidentService sequential operations: ${error}`,
         );
       });
 
@@ -749,19 +786,16 @@ export class Service extends DatabaseService<Model> {
   }
 
   @CaptureSpan()
-  private async createIncidentFeedAsync(
-    incident: Model,
-    createdItem: Model,
-  ): Promise<void> {
+  private async createIncidentFeedAsync(incident: Model): Promise<void> {
     try {
       const createdByUserId: ObjectID | undefined | null =
-        createdItem.createdByUserId || createdItem.createdByUser?.id;
+        incident.createdByUserId || incident.createdByUser?.id;
 
-      let feedInfoInMarkdown: string = `#### 🚨 Incident ${createdItem.incidentNumber?.toString()} Created: 
+      let feedInfoInMarkdown: string = `#### 🚨 Incident ${incident.incidentNumber?.toString()} Created: 
         
-**${createdItem.title || "No title provided."}**:
+**${incident.title || "No title provided."}**:
 
-${createdItem.description || "No description provided."}
+${incident.description || "No description provided."}
 
 `;
 
@@ -777,26 +811,26 @@ ${createdItem.description || "No description provided."}
         feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
 
         for (const monitor of incident.monitors) {
-          feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(createdItem.projectId!, monitor.id!)).toString()})\n`;
+          feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(incident.projectId!, monitor.id!)).toString()})\n`;
         }
 
         feedInfoInMarkdown += `\n\n`;
       }
 
-      if (createdItem.rootCause) {
+      if (incident.rootCause) {
         feedInfoInMarkdown += `\n
 📄 **Root Cause**:
 
-${createdItem.rootCause || "No root cause provided."}
+${incident.rootCause || "No root cause provided."}
 
 `;
       }
 
-      if (createdItem.remediationNotes) {
+      if (incident.remediationNotes) {
         feedInfoInMarkdown += `\n 
 🎯 **Remediation Notes**:
 
-${createdItem.remediationNotes || "No remediation notes provided."}
+${incident.remediationNotes || "No remediation notes provided."}
 
 
 `;
@@ -804,13 +838,13 @@ ${createdItem.remediationNotes || "No remediation notes provided."}
 
       const incidentCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
         await IncidentWorkspaceMessages.getIncidentCreateMessageBlocks({
-          incidentId: createdItem.id!,
-          projectId: createdItem.projectId!,
+          incidentId: incident.id!,
+          projectId: incident.projectId!,
         });
 
       await IncidentFeedService.createIncidentFeedItem({
-        incidentId: createdItem.id!,
-        projectId: createdItem.projectId!,
+        incidentId: incident.id!,
+        projectId: incident.projectId!,
         incidentFeedEventType: IncidentFeedEventType.IncidentCreated,
         displayColor: Red500,
         feedInfoInMarkdown: feedInfoInMarkdown,