@oneuptime/common 7.0.4019 → 7.0.4026

package/Server/Services/AlertStateTimelineService.ts

@@ -21,6 +21,8 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<AlertStateTimeline> {
   public constructor() {
@@ -336,9 +338,73 @@ ${createdItem.rootCause}`,
       logger.error(error);
     });
 
+    const isLastAlertState: boolean = await this.isLastAlertState({
+      projectId: createdItem.projectId!,
+      alertStateId: createdItem.alertStateId,
+    });
+
+    if (isLastAlertState) {
+      WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+        projectId: createdItem.projectId!,
+        notificationFor: {
+          alertId: createdItem.alertId,
+        },
+        sendMessageBeforeArchiving: {
+          _type: "WorkspacePayloadMarkdown",
+          text: `**[Alert ${alertNumber}](${(
+            await AlertService.getAlertLinkInDashboard(
+              createdItem.projectId!,
+              createdItem.alertId!,
+            )
+          ).toString()})** is resolved. Archiving channel.`,
+        },
+      }).catch((error: Error) => {
+        logger.error(`Error while archiving workspace channels:`);
+        logger.error(error);
+      });
+    }
+
     return createdItem;
   }
 
+  private async isLastAlertState(data: {
+    projectId: ObjectID;
+    alertStateId: ObjectID;
+  }): Promise<boolean> {
+    // find all the states for this project and sort it by order. Then, check if this is the last state.
+    const alertStates: AlertState[] = await AlertStateService.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const alertState: AlertState | null =
+      alertStates.find((alertState: AlertState) => {
+        return alertState.id?.toString() === data.alertStateId.toString();
+      }) || null;
+
+    if (!alertState) {
+      throw new BadDataException("Alert state not found.");
+    }
+
+    const lastAlertState: AlertState | undefined =
+      alertStates[alertStates.length - 1];
+
+    if (lastAlertState && lastAlertState.id) {
+      return lastAlertState.id.toString() === alertState.id?.toString();
+    }
+
+    return false;
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<AlertStateTimeline>,

package/Server/Services/IncidentStateTimelineService.ts

@@ -22,6 +22,8 @@ import logger from "../Utils/Logger";
 import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 
 export class Service extends DatabaseService<IncidentStateTimeline> {
   public constructor() {
@@ -359,9 +361,73 @@ ${createdItem.rootCause}`,
       logger.error(error);
     });
 
+    const isLastIncidentState: boolean = await this.isLastIncidentState({
+      projectId: createdItem.projectId!,
+      incidentStateId: createdItem.incidentStateId,
+    });
+
+    if (isLastIncidentState) {
+      WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+        projectId: createdItem.projectId!,
+        notificationFor: {
+          incidentId: createdItem.incidentId,
+        },
+        sendMessageBeforeArchiving: {
+          _type: "WorkspacePayloadMarkdown",
+          text: `**[Incident ${incidentNumber}](${(
+            await IncidentService.getIncidentLinkInDashboard(
+              createdItem.projectId!,
+              createdItem.incidentId!,
+            )
+          ).toString()})** is resolved. Archiving channel.`,
+        },
+      }).catch((error: Error) => {
+        logger.error(`Error while archiving workspace channels:`);
+        logger.error(error);
+      });
+    }
+
     return createdItem;
   }
 
+  private async isLastIncidentState(data: {
+    projectId: ObjectID;
+    incidentStateId: ObjectID;
+  }): Promise<boolean> {
+    // find all the states for this project and sort it by order. Then, check if this is the last state.
+    const incidentStates: IncidentState[] = await IncidentStateService.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const incidentState: IncidentState | null =
+      incidentStates.find((incidentState: IncidentState) => {
+        return incidentState.id?.toString() === data.incidentStateId.toString();
+      }) || null;
+
+    if (!incidentState) {
+      throw new BadDataException("Incident state not found.");
+    }
+
+    const lastIncidentState: IncidentState | undefined =
+      incidentStates[incidentStates.length - 1];
+
+    if (lastIncidentState && lastIncidentState.id) {
+      return lastIncidentState.id.toString() === incidentState.id?.toString();
+    }
+
+    return false;
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<IncidentStateTimeline>,

package/Server/Services/MonitorService.ts

@@ -56,12 +56,17 @@ import Label from "../../Models/DatabaseModels/Label";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
-import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
 import MonitorWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/Monitor";
 import MonitorFeedService from "./MonitorFeedService";
 import { MonitorFeedEventType } from "../../Models/DatabaseModels/MonitorFeed";
 import { Gray500, Green500 } from "../../Types/BrandColors";
 import LabelService from "./LabelService";
+import QueryOperator from "../../Types/BaseDatabase/QueryOperator";
+import { FindWhere } from "../../Types/BaseDatabase/Query";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -85,6 +90,49 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      let projectId: FindWhere<ObjectID> | QueryOperator<ObjectID> | undefined =
+        deleteBy.query.projectId || deleteBy.props.tenantId;
+
+      if (!projectId) {
+        // fetch this monitor from the database to get the projectId.
+        const monitor: Model | null = await this.findOneById({
+          id: new ObjectID(deleteBy.query._id as string) as ObjectID,
+          select: {
+            projectId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (!monitor) {
+          throw new BadDataException("Monitor not found.");
+        }
+
+        if (!monitor.id) {
+          throw new BadDataException("Monitor id not found.");
+        }
+
+        projectId = monitor.projectId!;
+      }
+
+      try {
+        await WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+          projectId: projectId as ObjectID,
+          notificationFor: {
+            monitorId: new ObjectID(deleteBy.query._id as string) as ObjectID,
+          },
+          sendMessageBeforeArchiving: {
+            _type: "WorkspacePayloadMarkdown",
+            text: `🗑️ This monitor is deleted. The channel is being archived.`,
+          },
+        });
+      } catch (error) {
+        logger.error(
+          `Error while archiving workspace channels for monitor ${deleteBy.query._id}: ${error}`,
+        );
+      }
     }
 
     return { deleteBy, carryForward: null };
@@ -434,6 +482,29 @@ ${createdItem.description || "No description provided."}
       feedInfoInMarkdown += `\n\n`;
     }
 
+    // send message to workspaces - slack, teams,   etc.
+    const workspaceResult: {
+      channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+    } | null =
+      await MonitorWorkspaceMessages.createChannelsAndInviteUsersToChannels({
+        projectId: createdItem.projectId,
+        monitorId: createdItem.id!,
+        monitorName: createdItem.name!,
+      });
+
+    if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+      // update incident with these channels.
+      await this.updateOneById({
+        id: createdItem.id!,
+        data: {
+          postUpdatesToWorkspaceChannels: workspaceResult.channelsCreated || [],
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     const monitorCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
       await MonitorWorkspaceMessages.getMonitorCreateMessageBlocks({
         monitorId: createdItem.id!,

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -27,6 +27,8 @@ import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 
 export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline> {
   public constructor() {
@@ -36,6 +38,53 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
     }
   }
 
+  private async isLastScheduledMaintenanceState(data: {
+    projectId: ObjectID;
+    scheduledMaintenanceStateId: ObjectID;
+  }): Promise<boolean> {
+    // find all the states for this project and sort it by order. Then, check if this is the last state.
+    const scheduledMaintenanceStates: ScheduledMaintenanceState[] =
+      await ScheduledMaintenanceStateService.findBy({
+        query: {
+          projectId: data.projectId,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        sort: {
+          order: SortOrder.Ascending,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const scheduledMaintenanceState: ScheduledMaintenanceState | null =
+      scheduledMaintenanceStates.find(
+        (scheduledMaintenanceState: ScheduledMaintenanceState) => {
+          return (
+            scheduledMaintenanceState.id?.toString() ===
+            data.scheduledMaintenanceStateId.toString()
+          );
+        },
+      ) || null;
+
+    if (!scheduledMaintenanceState) {
+      throw new BadDataException("ScheduledMaintenance state not found.");
+    }
+
+    const lastScheduledMaintenanceState: ScheduledMaintenanceState | undefined =
+      scheduledMaintenanceStates[scheduledMaintenanceStates.length - 1];
+
+    if (lastScheduledMaintenanceState && lastScheduledMaintenanceState.id) {
+      return (
+        lastScheduledMaintenanceState.id.toString() ===
+        scheduledMaintenanceState.id?.toString()
+      );
+    }
+
+    return false;
+  }
+
   @CaptureSpan()
   protected override async onBeforeCreate(
     createBy: CreateBy<ScheduledMaintenanceStateTimeline>,
@@ -361,6 +410,33 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
       await this.enableActiveMonitoringForMonitors(scheduledMaintenanceEvent!);
     }
 
+    const isLastScheduledMaintenanceState: boolean =
+      await this.isLastScheduledMaintenanceState({
+        projectId: createdItem.projectId!,
+        scheduledMaintenanceStateId: createdItem.scheduledMaintenanceStateId,
+      });
+
+    if (isLastScheduledMaintenanceState) {
+      WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+        projectId: createdItem.projectId!,
+        notificationFor: {
+          scheduledMaintenanceId: createdItem.scheduledMaintenanceId,
+        },
+        sendMessageBeforeArchiving: {
+          _type: "WorkspacePayloadMarkdown",
+          text: `**[Scheduled Event ${scheduledMaintenanceNumber}](${(
+            await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(
+              createdItem.projectId!,
+              createdItem.scheduledMaintenanceId!,
+            )
+          ).toString()})** is complete. Archiving channel.`,
+        },
+      }).catch((error: Error) => {
+        logger.error(`Error while archiving workspace channels:`);
+        logger.error(error);
+      });
+    }
+
     return createdItem;
   }
 

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -264,6 +264,87 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     }
   }
 
+  @CaptureSpan()
+  public async archiveWorkspaceChannels(data: {
+    projectId: ObjectID;
+    notificationFor: NotificationFor;
+    sendMessageBeforeArchiving: WorkspacePayloadMarkdown;
+  }): Promise<void> {
+    const workspaceTypes: Array<WorkspaceType> = Service.getAllWorkspaceTypes();
+
+    for (const workspaceType of workspaceTypes) {
+      const notificationRules: Array<WorkspaceNotificationRule> =
+        await this.getMatchingNotificationRules({
+          projectId: data.projectId,
+          notificationFor: data.notificationFor,
+          workspaceType: workspaceType,
+          notificationRuleEventType: this.getNotificationRuleEventType(
+            data.notificationFor,
+          ),
+        });
+
+      // check if any of these rules have archive channel to true.
+      let shouldArchiveChannel: boolean = false;
+
+      for (const notificationRule of notificationRules) {
+        const rule: CreateChannelNotificationRule =
+          notificationRule.notificationRule as CreateChannelNotificationRule;
+        if (rule && rule.archiveChannelAutomatically) {
+          shouldArchiveChannel = true;
+          break;
+        }
+      }
+
+      if (!shouldArchiveChannel) {
+        continue; // check next workspace type.
+      }
+
+      const channels: Array<WorkspaceChannel> =
+        await this.getWorkspaceChannelsByNotificationFor({
+          projectId: data.projectId,
+          notificationFor: data.notificationFor,
+          workspaceType: workspaceType,
+        });
+
+      const channelIds: Array<string> = channels.map(
+        (channel: WorkspaceChannel) => {
+          return channel.id;
+        },
+      );
+
+      // get project auth token.
+      const projectAuth: WorkspaceProjectAuthToken | null =
+        await WorkspaceProjectAuthTokenService.findOneBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: workspaceType,
+          },
+          select: {
+            authToken: true,
+            miscData: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!projectAuth || !projectAuth.authToken) {
+        logger.debug("No project auth found for workspace type");
+        continue;
+      }
+
+      await WorkspaceUtil.getWorkspaceTypeUtil(workspaceType).archiveChannels({
+        authToken: projectAuth.authToken!,
+        channelIds: channelIds,
+        userId: this.getBotUserIdFromprojectAuthToken({
+          projectAuthToken: projectAuth,
+          workspaceType: workspaceType,
+        }),
+        sendMessageBeforeArchiving: data.sendMessageBeforeArchiving,
+      });
+    }
+  }
+
   @CaptureSpan()
   public async sendWorkspaceMarkdownNotification(data: {
     projectId: ObjectID;
@@ -316,43 +397,12 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           notificationFor: data.notificationFor,
         });
 
-      let monitorChannels: Array<WorkspaceChannel> = [];
-
-      if (data.notificationFor.monitorId) {
-        monitorChannels = await MonitorService.getWorkspaceChannelForMonitor({
-          monitorId: data.notificationFor.monitorId,
-          workspaceType: messageBlocksByWorkspaceType.workspaceType,
-        });
-      }
-
-      // incidents
-      if (data.notificationFor.incidentId) {
-        monitorChannels = await IncidentService.getWorkspaceChannelForIncident({
-          incidentId: data.notificationFor.incidentId,
-          workspaceType: messageBlocksByWorkspaceType.workspaceType,
-        });
-      }
-
-      // alerts
-      if (data.notificationFor.alertId) {
-        monitorChannels = await AlertService.getWorkspaceChannelForAlert({
-          alertId: data.notificationFor.alertId,
+      const monitorChannels: Array<WorkspaceChannel> =
+        await this.getWorkspaceChannelsByNotificationFor({
+          projectId: data.projectId,
+          notificationFor: data.notificationFor,
           workspaceType: messageBlocksByWorkspaceType.workspaceType,
         });
-      }
-
-      // scheduled maintenance
-
-      if (data.notificationFor.scheduledMaintenanceId) {
-        monitorChannels =
-          await ScheduledMaintenanceService.getWorkspaceChannelForScheduledMaintenance(
-            {
-              scheduledMaintenanceId:
-                data.notificationFor.scheduledMaintenanceId,
-              workspaceType: messageBlocksByWorkspaceType.workspaceType,
-            },
-          );
-      }
 
       const workspaceMessagePayload: WorkspaceMessagePayload = {
         _type: "WorkspaceMessagePayload",
@@ -374,6 +424,49 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     });
   }
 
+  private async getWorkspaceChannelsByNotificationFor(data: {
+    projectId: ObjectID;
+    notificationFor: NotificationFor;
+    workspaceType: WorkspaceType;
+  }): Promise<Array<WorkspaceChannel>> {
+    let monitorChannels: Array<WorkspaceChannel> = [];
+
+    if (data.notificationFor.monitorId) {
+      monitorChannels = await MonitorService.getWorkspaceChannelForMonitor({
+        monitorId: data.notificationFor.monitorId,
+        workspaceType: data.workspaceType,
+      });
+    }
+
+    // incidents
+    if (data.notificationFor.incidentId) {
+      monitorChannels = await IncidentService.getWorkspaceChannelForIncident({
+        incidentId: data.notificationFor.incidentId,
+        workspaceType: data.workspaceType,
+      });
+    }
+
+    // alerts
+    if (data.notificationFor.alertId) {
+      monitorChannels = await AlertService.getWorkspaceChannelForAlert({
+        alertId: data.notificationFor.alertId,
+        workspaceType: data.workspaceType,
+      });
+    }
+
+    // scheduled maintenance
+    if (data.notificationFor.scheduledMaintenanceId) {
+      monitorChannels =
+        await ScheduledMaintenanceService.getWorkspaceChannelForScheduledMaintenance(
+          {
+            scheduledMaintenanceId: data.notificationFor.scheduledMaintenanceId,
+            workspaceType: data.workspaceType,
+          },
+        );
+    }
+    return monitorChannels;
+  }
+
   private getNotificationRuleEventType(
     notificationFor: NotificationFor,
   ): NotificationRuleEventType {

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -158,6 +158,65 @@ export default class SlackUtil extends WorkspaceBase {
     });
   }
 
+  @CaptureSpan()
+  public static override async archiveChannels(data: {
+    userId: string;
+    channelIds: Array<string>;
+    authToken: string;
+    sendMessageBeforeArchiving: WorkspacePayloadMarkdown;
+  }): Promise<void> {
+    if (data.sendMessageBeforeArchiving) {
+      await this.sendMessage({
+        workspaceMessagePayload: {
+          _type: "WorkspaceMessagePayload",
+          channelNames: [],
+          channelIds: data.channelIds,
+          messageBlocks: [data.sendMessageBeforeArchiving],
+          workspaceType: WorkspaceType.Slack,
+        },
+        authToken: data.authToken,
+        userId: data.userId,
+      });
+    }
+
+    logger.debug("Archiving channels with data:");
+    logger.debug(data);
+
+    for (const channelId of data.channelIds) {
+      const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.post(
+          URL.fromString("https://slack.com/api/conversations.archive"),
+          {
+            channel: channelId,
+          },
+          {
+            Authorization: `Bearer ${data.authToken}`,
+            ["Content-Type"]: "application/x-www-form-urlencoded",
+          },
+        );
+
+      logger.debug("Response from Slack API for archiving channel:");
+      logger.debug(response);
+
+      if (response instanceof HTTPErrorResponse) {
+        logger.error("Error response from Slack API:");
+        logger.error(response);
+        throw response;
+      }
+
+      if ((response.jsonData as JSONObject)?.["ok"] !== true) {
+        logger.error("Invalid response from Slack API:");
+        logger.error(response.jsonData);
+        const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+          "error"
+        ] as string;
+        throw new BadRequestException("Error from Slack " + messageFromSlack);
+      }
+    }
+
+    logger.debug("Channels archived successfully.");
+  }
+
   @CaptureSpan()
   public static override async joinChannel(data: {
     authToken: string;

package/Server/Utils/Workspace/WorkspaceBase.ts

@@ -57,6 +57,16 @@ export default class WorkspaceBase {
     throw new NotImplementedException();
   }
 
+  @CaptureSpan()
+  public static async archiveChannels(_data: {
+    channelIds: Array<string>;
+    authToken: string;
+    userId: string;
+    sendMessageBeforeArchiving: WorkspacePayloadMarkdown;
+  }): Promise<void> {
+    throw new NotImplementedException();
+  }
+
   @CaptureSpan()
   public static async getUsernameFromUserId(_data: {
     authToken: string;

package/Types/Workspace/NotificationRules/CreateChannelNotificationRule.ts

@@ -11,4 +11,8 @@ export default interface CreateChannelNotificationRule
   inviteUsersToNewChannel: Array<ObjectID>;
   shouldInviteOwnersToNewChannel: boolean;
   newChannelTemplateName: string;
+
+  // if selected this would archive channel when incident, alert, scheduled maintenance reaches the last state (is resolved)
+  // This would only archive the channel which was created.
+  archiveChannelAutomatically: boolean;
 }