@oneuptime/common 7.0.5098 → 8.0.5124

package/Server/Services/MonitorService.ts

@@ -504,105 +504,122 @@ ${createdItem.description?.trim() || "No description provided."}
       feedInfoInMarkdown += `\n\n`;
     }
 
-    // Parallelize operations that don't depend on each other
-    const parallelOperations: Array<Promise<any>> = [];
-
-    // 1. Essential monitor status operation (must complete first)
-    await this.changeMonitorStatus(
-      createdItem.projectId,
-      [createdItem.id],
-      createdItem.currentMonitorStatusId,
-      false, // notifyOwners = false
-      "This status was created when the monitor was created.",
-      undefined,
-      onCreate.createBy.props,
-    );
-
-    // 2. Start core operations in parallel that can run asynchronously (excluding workspace operations)
-
-    // Add default probes if needed (can be slow with many probes)
-    if (
-      createdItem.monitorType &&
-      MonitorTypeHelper.isProbableMonitor(createdItem.monitorType)
-    ) {
-      parallelOperations.push(
-        this.addDefaultProbesToMonitor(
-          createdItem.projectId,
-          createdItem.id,
-        ).catch((error: Error) => {
-          logger.error("Error in adding default probes");
-          logger.error(error);
-          // Don't fail monitor creation due to probe creation issues
-        }),
-      );
-    }
-
-    // Billing operations
-    if (IsBillingEnabled) {
-      parallelOperations.push(
-        ActiveMonitoringMeteredPlan.reportQuantityToBillingProvider(
-          createdItem.projectId,
-        ).catch((error: Error) => {
-          logger.error("Error in billing operations");
-          logger.error(error);
-          // Don't fail monitor creation due to billing issues
-        }),
-      );
-    }
-
-    // Owner operations
-    if (
-      onCreate.createBy.miscDataProps &&
-      (onCreate.createBy.miscDataProps["ownerTeams"] ||
-        onCreate.createBy.miscDataProps["ownerUsers"])
-    ) {
-      parallelOperations.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,
-        ).catch((error: Error) => {
-          logger.error("Error in adding owners");
-          logger.error(error);
-          // Don't fail monitor creation due to owner issues
-        }),
-      );
-    }
-
-    // Probe status refresh (can be expensive with many probes)
-    parallelOperations.push(
-      this.refreshMonitorProbeStatus(createdItem.id).catch((error: Error) => {
-        logger.error("Error in refreshing probe status");
-        logger.error(error);
-        // Don't fail monitor creation due to probe status issues
-      }),
-    );
-
-    // Wait for core operations to complete, then handle workspace operations
-    Promise.allSettled(parallelOperations)
-      .then(() => {
-        // Handle workspace operations after core operations complete
-        // Run workspace operations in background without blocking response
-        this.handleWorkspaceOperationsAsync({
-          projectId: createdItem.projectId!,
-          monitorId: createdItem.id!,
-          monitorName: createdItem.name!,
-          feedInfoInMarkdown,
-          createdByUserId,
-        }).catch((error: Error) => {
-          logger.error("Error in workspace operations");
-          logger.error(error);
-          // Don't fail monitor creation due to workspace issues
-        });
+    // Execute operations sequentially with error handling (workspace first)
+    Promise.resolve()
+      .then(async () => {
+        try {
+          return await this.handleWorkspaceOperationsAsync({
+            projectId: createdItem.projectId!,
+            monitorId: createdItem.id!,
+            monitorName: createdItem.name!,
+            feedInfoInMarkdown,
+            createdByUserId,
+          });
+        } catch (error) {
+          logger.error(
+            "Workspace operations failed in MonitorService.onCreateSuccess",
+          );
+          logger.error(error as Error);
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.changeMonitorStatus(
+            createdItem.projectId!,
+            [createdItem.id!],
+            createdItem.currentMonitorStatusId!,
+            false, // notifyOwners = false
+            "This status was created when the monitor was created.",
+            undefined,
+            onCreate.createBy.props,
+          );
+        } catch (error) {
+          logger.error(
+            "Change monitor status failed in MonitorService.onCreateSuccess",
+          );
+          logger.error(error as Error);
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          if (
+            createdItem.monitorType &&
+            MonitorTypeHelper.isProbableMonitor(createdItem.monitorType)
+          ) {
+            return await this.addDefaultProbesToMonitor(
+              createdItem.projectId!,
+              createdItem.id!,
+            );
+          }
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            "Add default probes failed in MonitorService.onCreateSuccess",
+          );
+          logger.error(error as Error);
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          if (IsBillingEnabled) {
+            return await ActiveMonitoringMeteredPlan.reportQuantityToBillingProvider(
+              createdItem.projectId!,
+            );
+          }
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            "Billing operations failed in MonitorService.onCreateSuccess",
+          );
+          logger.error(error as 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 MonitorService.onCreateSuccess");
+          logger.error(error as Error);
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.refreshMonitorProbeStatus(createdItem.id!);
+        } catch (error) {
+          logger.error(
+            "Refresh probe status failed in MonitorService.onCreateSuccess",
+          );
+          logger.error(error as Error);
+          return Promise.resolve();
+        }
       })
       .catch((error: Error) => {
-        logger.error("Error in parallel monitor creation operations");
-        logger.error(error);
+        logger.error(
+          `Critical error in MonitorService sequential operations: ${error}`,
+        );
       });
 
     return createdItem;

package/Server/Services/ScheduledMaintenanceService.ts

@@ -610,6 +610,12 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
         labels: {
           name: true,
         },
+        createdByUserId: true,
+        createdByUser: {
+          _id: true,
+          name: true,
+          email: true,
+        },
       },
       props: {
         isRoot: true,
@@ -620,71 +626,80 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
       throw new BadDataException("Scheduled Maintenance not found");
     }
 
-    // Execute core operations in parallel first
-    const coreOperations: Array<Promise<any>> = [];
-
-    // Create feed item asynchronously
-    coreOperations.push(
-      this.createScheduledMaintenanceFeedAsync(
-        scheduledMaintenance,
-        createdItem,
-      ),
-    );
-
-    // Create state timeline asynchronously
-    coreOperations.push(
-      this.createScheduledMaintenanceStateTimelineAsync(createdItem),
-    );
-
-    // Handle owner assignment asynchronously
-    if (
-      createdItem.projectId &&
-      createdItem.id &&
-      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") {
-            logger.error(
-              `Core operation ${index} failed in ScheduledMaintenanceService.onCreateSuccess: ${result.reason}`,
+    // Execute operations sequentially with error handling
+    Promise.resolve()
+      .then(async () => {
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            return await this.handleScheduledMaintenanceWorkspaceOperationsAsync(
+              createdItem,
             );
           }
-        });
-
-        // Handle workspace operations after core operations complete
-        if (createdItem.projectId && createdItem.id) {
-          // Run workspace operations in background without blocking response
-          this.handleScheduledMaintenanceWorkspaceOperationsAsync(
+          return Promise.resolve();
+        } catch (error) {
+          logger.error(
+            `Workspace operations failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.createScheduledMaintenanceFeedAsync(
+            scheduledMaintenance,
+          );
+        } catch (error) {
+          logger.error(
+            `Create scheduled maintenance feed failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          return await this.createScheduledMaintenanceStateTimelineAsync(
             createdItem,
-          ).catch((error: Error) => {
-            logger.error(
-              `Workspace operations failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+          );
+        } catch (error) {
+          logger.error(
+            `Create scheduled maintenance state timeline failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
+      .then(async () => {
+        try {
+          if (
+            createdItem.projectId &&
+            createdItem.id &&
+            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 ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
         }
       })
       .catch((error: Error) => {
         logger.error(
-          `Critical error in ScheduledMaintenanceService core operations: ${error}`,
+          `Critical error in ScheduledMaintenanceService sequential operations: ${error}`,
         );
       });
 
@@ -738,17 +753,17 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
   @CaptureSpan()
   private async createScheduledMaintenanceFeedAsync(
     scheduledMaintenance: Model,
-    createdItem: Model,
   ): Promise<void> {
     try {
       const createdByUserId: ObjectID | undefined | null =
-        createdItem.createdByUserId || createdItem.createdByUser?.id;
+        scheduledMaintenance.createdByUserId ||
+        scheduledMaintenance.createdByUser?.id;
 
-      let feedInfoInMarkdown: string = `#### 🕒 Scheduled Maintenance ${createdItem.scheduledMaintenanceNumber?.toString()} Created: 
+      let feedInfoInMarkdown: string = `#### 🕒 Scheduled Maintenance ${scheduledMaintenance.scheduledMaintenanceNumber?.toString()} Created: 
             
-**${createdItem.title || "No title provided."}**:
+**${scheduledMaintenance.title || "No title provided."}**:
       
-${createdItem.description || "No description provided."}
+${scheduledMaintenance.description || "No description provided."}
       
 `;
 
@@ -772,7 +787,7 @@ ${createdItem.description || "No description provided."}
         feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
 
         for (const monitor of scheduledMaintenance.monitors) {
-          feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(createdItem.projectId!, monitor.id!)).toString()})\n`;
+          feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(scheduledMaintenance.projectId!, monitor.id!)).toString()})\n`;
         }
 
         feedInfoInMarkdown += `\n\n`;
@@ -781,14 +796,14 @@ ${createdItem.description || "No description provided."}
       const scheduledMaintenanceCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
         await ScheduledMaintenanceWorkspaceMessages.getScheduledMaintenanceCreateMessageBlocks(
           {
-            scheduledMaintenanceId: createdItem.id!,
-            projectId: createdItem.projectId!,
+            scheduledMaintenanceId: scheduledMaintenance.id!,
+            projectId: scheduledMaintenance.projectId!,
           },
         );
 
       await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
-        scheduledMaintenanceId: createdItem.id!,
-        projectId: createdItem.projectId!,
+        scheduledMaintenanceId: scheduledMaintenance.id!,
+        projectId: scheduledMaintenance.projectId!,
         scheduledMaintenanceFeedEventType:
           ScheduledMaintenanceFeedEventType.ScheduledMaintenanceCreated,
         displayColor: Red500,

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -611,6 +611,9 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     notificationFor: NotificationFor;
     workspaceType: WorkspaceType;
   }): Promise<Array<WorkspaceChannel>> {
+    logger.debug("getWorkspaceChannelsByNotificationFor called with data:");
+    logger.debug(JSON.stringify(data, null, 2));
+
     let monitorChannels: Array<WorkspaceChannel> = [];
 
     if (data.notificationFor.monitorId) {
@@ -654,6 +657,10 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           },
         );
     }
+
+    logger.debug("Workspace channels found:");
+    logger.debug(monitorChannels);
+
     return monitorChannels;
   }
 
@@ -758,112 +765,132 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
   }): Promise<{
     channelsCreated: Array<NotificationRuleWorkspaceChannel>;
   } | null> {
-    logger.debug(
-      "WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules",
-    );
-    logger.debug(data);
+    try {
+      logger.debug(
+        "WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules",
+      );
+      logger.debug(data);
 
-    const channelsCreated: Array<NotificationRuleWorkspaceChannel> = [];
+      const channelsCreated: Array<NotificationRuleWorkspaceChannel> = [];
 
-    const projectAuths: Array<WorkspaceProjectAuthToken> =
-      await WorkspaceProjectAuthTokenService.getProjectAuths({
-        projectId: data.projectId,
-      });
-
-    logger.debug("projectAuths");
-    logger.debug(projectAuths);
+      const projectAuths: Array<WorkspaceProjectAuthToken> =
+        await WorkspaceProjectAuthTokenService.getProjectAuths({
+          projectId: data.projectId,
+        });
 
-    if (!projectAuths || projectAuths.length === 0) {
-      // do nothing.
-      return null;
-    }
+      logger.debug("projectAuths");
+      logger.debug(projectAuths);
 
-    for (const projectAuth of projectAuths) {
-      if (!projectAuth.authToken) {
-        continue;
+      if (!projectAuths || projectAuths.length === 0) {
+        // do nothing.
+        return null;
       }
 
-      if (!projectAuth.workspaceType) {
-        continue;
-      }
+      for (const projectAuth of projectAuths) {
+        try {
+          if (!projectAuth.authToken) {
+            continue;
+          }
 
-      const authToken: string = projectAuth.authToken;
-      const workspaceType: WorkspaceType = projectAuth.workspaceType;
+          if (!projectAuth.workspaceType) {
+            continue;
+          }
 
-      const notificationRules: Array<WorkspaceNotificationRule> =
-        await this.getMatchingNotificationRules({
-          projectId: data.projectId,
-          workspaceType: workspaceType,
-          notificationRuleEventType: data.notificationRuleEventType,
-          notificationFor: data.notificationFor,
-        });
+          const authToken: string = projectAuth.authToken;
+          const workspaceType: WorkspaceType = projectAuth.workspaceType;
 
-      logger.debug("notificationRules");
-      logger.debug(notificationRules);
+          const notificationRules: Array<WorkspaceNotificationRule> =
+            await this.getMatchingNotificationRules({
+              projectId: data.projectId,
+              workspaceType: workspaceType,
+              notificationRuleEventType: data.notificationRuleEventType,
+              notificationFor: data.notificationFor,
+            });
 
-      if (!notificationRules || notificationRules.length === 0) {
-        return null;
-      }
+          logger.debug("notificationRules");
+          logger.debug(notificationRules);
 
-      logger.debug("Creating channels based on rules");
-      const createdWorkspaceChannels: Array<NotificationRuleWorkspaceChannel> =
-        await this.createChannelsBasedOnRules({
-          projectId: data.projectId,
-          projectOrUserAuthTokenForWorkspace: authToken,
-          workspaceType: workspaceType,
-          notificationRules: notificationRules,
-          channelNameSiffix: data.channelNameSiffix,
-          notificationEventType: data.notificationRuleEventType,
-          notificationFor: data.notificationFor,
-        });
+          if (!notificationRules || notificationRules.length === 0) {
+            return null;
+          }
 
-      logger.debug("createdWorkspaceChannels");
-      logger.debug(createdWorkspaceChannels);
+          logger.debug("Creating channels based on rules");
+          const createdWorkspaceChannels: Array<NotificationRuleWorkspaceChannel> =
+            await this.createChannelsBasedOnRules({
+              projectId: data.projectId,
+              projectOrUserAuthTokenForWorkspace: authToken,
+              workspaceType: workspaceType,
+              notificationRules: notificationRules,
+              channelNameSiffix: data.channelNameSiffix,
+              notificationEventType: data.notificationRuleEventType,
+              notificationFor: data.notificationFor,
+            });
 
-      logger.debug("Inviting users and teams to channels based on rules");
-      await this.inviteUsersAndTeamsToChannelsBasedOnRules({
-        projectId: data.projectId,
-        projectAuth: projectAuth,
-        workspaceType: workspaceType,
-        notificationRules: notificationRules,
-        notificationChannels: createdWorkspaceChannels,
-      });
+          logger.debug("createdWorkspaceChannels");
+          logger.debug(createdWorkspaceChannels);
 
-      logger.debug("Getting existing channel names from notification rules");
-      const existingChannelNames: Array<string> =
-        this.getExistingChannelNamesFromNotificationRules({
-          notificationRules: notificationRules.map(
-            (rule: WorkspaceNotificationRule) => {
-              return rule.notificationRule as BaseNotificationRule;
-            },
-          ),
-        }) || [];
+          logger.debug("Inviting users and teams to channels based on rules");
+          await this.inviteUsersAndTeamsToChannelsBasedOnRules({
+            projectId: data.projectId,
+            projectAuth: projectAuth,
+            workspaceType: workspaceType,
+            notificationRules: notificationRules,
+            notificationChannels: createdWorkspaceChannels,
+          });
 
-      logger.debug("Existing channel names:");
-      logger.debug(existingChannelNames);
+          logger.debug(
+            "Getting existing channel names from notification rules",
+          );
+          const existingChannelNames: Array<string> =
+            this.getExistingChannelNamesFromNotificationRules({
+              notificationRules: notificationRules.map(
+                (rule: WorkspaceNotificationRule) => {
+                  return rule.notificationRule as BaseNotificationRule;
+                },
+              ),
+            }) || [];
 
-      logger.debug("Adding created channel names to existing channel names");
-      for (const channel of createdWorkspaceChannels) {
-        if (!existingChannelNames.includes(channel.name)) {
-          existingChannelNames.push(channel.name);
-        }
-      }
+          logger.debug("Existing channel names:");
+          logger.debug(existingChannelNames);
 
-      logger.debug("Final list of channel names to post messages to:");
-      logger.debug(existingChannelNames);
+          logger.debug(
+            "Adding created channel names to existing channel names",
+          );
+          for (const channel of createdWorkspaceChannels) {
+            if (!existingChannelNames.includes(channel.name)) {
+              existingChannelNames.push(channel.name);
+            }
+          }
 
-      logger.debug("Posting messages to workspace channels");
+          logger.debug("Final list of channel names to post messages to:");
+          logger.debug(existingChannelNames);
 
-      logger.debug("Channels created:");
-      logger.debug(createdWorkspaceChannels);
+          logger.debug("Posting messages to workspace channels");
 
-      channelsCreated.push(...createdWorkspaceChannels);
-    }
+          logger.debug("Channels created:");
+          logger.debug(createdWorkspaceChannels);
 
-    logger.debug("Returning created channels");
-    return {
-      channelsCreated: channelsCreated,
-    };
+          channelsCreated.push(...createdWorkspaceChannels);
+        } catch (err) {
+          logger.error(
+            "Error in creating channels and inviting users to channels for workspace type " +
+              projectAuth.workspaceType,
+          );
+          logger.error(err);
+        }
+      }
+
+      logger.debug("Returning created channels");
+      return {
+        channelsCreated: channelsCreated,
+      };
+    } catch (err) {
+      logger.error(
+        "Error in createChannelsAndInviteUsersToChannelsBasedOnRules:",
+      );
+      logger.error(err);
+      return null;
+    }
   }
 
   @CaptureSpan()