@oneuptime/common 7.0.3526 → 7.0.3546

package/Server/Services/AlertOwnerTeamService.ts

@@ -1,10 +1,122 @@
+import Team from "../../Models/DatabaseModels/Team";
+import ObjectID from "../../Types/ObjectID";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/AlertOwnerTeam";
+import TeamService from "./TeamService";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        alertId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const alertId: ObjectID | undefined = item.alertId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (alertId && teamId && projectId) {
+        const team: Team | null = await TeamService.findOneById({
+          id: teamId,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (team && team.name) {
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: projectId,
+            alertFeedEventType: AlertFeedEventType.OwnerTeamRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**Team ${team.name}** was removed from the alert as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add alert feed.
+
+    const alertId: ObjectID | undefined = createdItem.alertId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (alertId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await AlertFeedService.createAlertFeed({
+          alertId: alertId,
+          projectId: projectId,
+          alertFeedEventType: AlertFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**Team ${team.name}** was added to the alert as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/AlertOwnerUserService.ts

@@ -1,10 +1,124 @@
+import User from "../../Models/DatabaseModels/User";
+import ObjectID from "../../Types/ObjectID";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/AlertOwnerUser";
+import UserService from "./UserService";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        alertId: true,
+        projectId: true,
+        userId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const alertId: ObjectID | undefined = item.alertId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (alertId && userId && projectId) {
+        const user: User | null = await UserService.findOneById({
+          id: userId,
+          select: {
+            name: true,
+            email: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (user && user.name) {
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: projectId,
+            alertFeedEventType: AlertFeedEventType.OwnerUserRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the alert as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add alert feed.
+
+    const alertId: ObjectID | undefined = createdItem.alertId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (alertId && userId && projectId) {
+      const user: User | null = await UserService.findOneById({
+        id: userId,
+        select: {
+          name: true,
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (user && user.name) {
+        await AlertFeedService.createAlertFeed({
+          alertId: alertId,
+          projectId: projectId,
+          alertFeedEventType: AlertFeedEventType.OwnerUserAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the alert as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/AlertService.ts

@@ -38,6 +38,9 @@ import Metric, {
   ServiceType,
 } from "../../Models/AnalyticsModels/Metric";
 import AlertMetricType from "../../Types/Alerts/AlertMetricType";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -224,6 +227,48 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("currentAlertStateId is required");
     }
 
+    const createdByUserId: ObjectID | undefined | null =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.AlertCreated,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Alert Created**: 
+          
+  **Alert Title**:
+  
+  ${createdItem.title || "No title provided."}
+  
+  **Description**:
+  
+  ${createdItem.description || "No description provided."}
+    
+          `,
+      userId: createdByUserId || undefined,
+    });
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.RootCause,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Root Cause**
+        
+${createdItem.rootCause || "No root cause provided."}`,
+    });
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.RemediationNotes,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Remediation Notes**
+        
+${createdItem.remediationNotes || "No remediation notes provided."}`,
+    });
+
     await this.changeAlertState({
       projectId: createdItem.projectId,
       alertId: createdItem.id,
@@ -445,6 +490,82 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    if (updatedItemIds.length > 0) {
+      for (const alertId of updatedItemIds) {
+        if (onUpdate.updateBy.data.title) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Alert title was updated.** Here's the new title.
+    
+${onUpdate.updateBy.data.title || "No title provided."}
+              `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.rootCause) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Alert root cause was updated.** Here's the new root cause.
+          
+${onUpdate.updateBy.data.rootCause || "No root cause provided."}
+            `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.description) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Alert description was updated.** Here's the new description.
+          
+${onUpdate.updateBy.data.description || "No description provided."}
+            `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.remediationNotes) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Remediation notes were updated.** Here are the new notes.
+    
+${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
+                `,
+            userId: createdByUserId || undefined,
+          });
+        }
+      }
+    }
+
     return onUpdate;
   }
 

package/Server/Services/AlertStateTimelineService.ts

@@ -19,6 +19,8 @@ import { JSONObject } from "../../Types/JSON";
 import AlertInternalNote from "../../Models/DatabaseModels/AlertInternalNote";
 import AlertInternalNoteService from "./AlertInternalNoteService";
 import logger from "../Utils/Logger";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 
 export class Service extends DatabaseService<AlertStateTimeline> {
   public constructor() {
@@ -130,10 +132,15 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       });
     }
 
+    const privateNote: string | undefined = (
+      createBy.miscDataProps as JSONObject | undefined
+    )?.["privateNote"] as string | undefined;
+
     return {
       createBy,
       carryForward: {
         lastAlertStateTimelineId: lastAlertStateTimeline?.id || null,
+        privateNote: privateNote,
       },
     };
   }
@@ -164,6 +171,36 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       });
     }
 
+    const alertState: AlertState | null = await AlertStateService.findOneBy({
+      query: {
+        _id: createdItem.alertStateId.toString()!,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+        isResolvedState: true,
+        isAcknowledgedState: true,
+        isCreatedState: true,
+        color: true,
+        name: true,
+      },
+    });
+
+    const stateName: string = alertState?.name || "";
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.alertId!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.AlertStateChanged,
+      displayColor: alertState?.color,
+      feedInfoInMarkdown: "**Alert State** changed to **" + stateName + "**",
+      moreInformationInMarkdown: `**Cause:** 
+${createdItem.rootCause}`,
+      userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+    });
+
     await AlertService.updateOneBy({
       query: {
         _id: createdItem.alertId?.toString(),
@@ -174,6 +211,21 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       props: onCreate.createBy.props,
     });
 
+    if (onCreate.carryForward.privateNote) {
+      const privateNote: string = onCreate.carryForward.privateNote;
+
+      const alertInternalNote: AlertInternalNote = new AlertInternalNote();
+      alertInternalNote.alertId = createdItem.alertId;
+      alertInternalNote.note = privateNote;
+      alertInternalNote.createdAt = createdItem.startsAt!;
+      alertInternalNote.projectId = createdItem.projectId!;
+
+      await AlertInternalNoteService.create({
+        data: alertInternalNote,
+        props: onCreate.createBy.props,
+      });
+    }
+
     AlertService.refreshAlertMetrics({
       alertId: createdItem.alertId,
     }).catch((error: Error) => {

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -30,6 +30,7 @@ import OnCallDutyPolicyEscalationRuleTeam from "Common/Models/DatabaseModels/OnC
 import OnCallDutyPolicyEscalationRuleUser from "Common/Models/DatabaseModels/OnCallDutyPolicyEscalationRuleUser";
 import OnCallDutyPolicyExecutionLogTimeline from "Common/Models/DatabaseModels/OnCallDutyPolicyExecutionLogTimeline";
 import User from "Common/Models/DatabaseModels/User";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public async startRuleExecution(
@@ -37,12 +38,13 @@ export class Service extends DatabaseService<Model> {
     options: {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
+      triggeredByAlertId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId: ObjectID;
       onCallPolicyId: ObjectID;
     },
   ): Promise<void> {
-    // add log timeline.
+    logger.debug(`Starting rule execution for ruleId: ${ruleId.toString()}`);
 
     const rule: Model | null = await this.findOneById({
       id: ruleId,
@@ -62,6 +64,8 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    logger.debug(`Found rule: ${JSON.stringify(rule)}`);
+
     await OnCallDutyPolicyExecutionLogService.updateOneById({
       id: options.onCallPolicyExecutionLogId,
       data: {
@@ -75,6 +79,8 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
+    logger.debug(`Updated execution log for ruleId: ${ruleId.toString()}`);
+
     type GetNewLogFunction = () => OnCallDutyPolicyExecutionLogTimeline;
 
     const getNewLog: GetNewLogFunction =
@@ -92,6 +98,10 @@ export class Service extends DatabaseService<Model> {
           log.triggeredByIncidentId = options.triggeredByIncidentId;
         }
 
+        if (options.triggeredByAlertId) {
+          log.triggeredByAlertId = options.triggeredByAlertId;
+        }
+
         return log;
       };
 
@@ -105,6 +115,16 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    if (
+      UserNotificationEventType.AlertCreated ===
+        options.userNotificationEventType &&
+      !options.triggeredByAlertId
+    ) {
+      throw new BadDataException(
+        "triggeredByAlertId is required when userNotificationEventType is IncidentCreated",
+      );
+    }
+
     const usersInRule: Array<OnCallDutyPolicyEscalationRuleUser> =
       await OnCallDutyPolicyEscalationRuleUserService.findBy({
         query: {
@@ -120,6 +140,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+    logger.debug(`Found users in rule: ${JSON.stringify(usersInRule)}`);
+
     const teamsInRule: Array<OnCallDutyPolicyEscalationRuleTeam> =
       await OnCallDutyPolicyEscalationRuleTeamService.findBy({
         query: {
@@ -135,6 +157,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+    logger.debug(`Found teams in rule: ${JSON.stringify(teamsInRule)}`);
+
     const schedulesInRule: Array<OnCallDutyPolicyEscalationRuleSchedule> =
       await OnCallDutyPolicyEscalationRuleScheduleService.findBy({
         query: {
@@ -150,7 +174,7 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-    // get unique users and notify all the users.
+    logger.debug(`Found schedules in rule: ${JSON.stringify(schedulesInRule)}`);
 
     type StartUserNotificationRuleExecutionFunction = (
       userId: ObjectID,
@@ -164,7 +188,9 @@ export class Service extends DatabaseService<Model> {
         teamId: ObjectID | null,
         scheduleId: ObjectID | null,
       ): Promise<void> => {
-        // no users in this rule. Skipping.
+        logger.debug(
+          `Starting notification rule execution for userId: ${userId.toString()}`,
+        );
         let log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage = "Sending notification to user.";
         log.status = OnCallDutyExecutionLogTimelineStatus.Executing;
@@ -189,6 +215,7 @@ export class Service extends DatabaseService<Model> {
           {
             userNotificationEventType: options.userNotificationEventType!,
             triggeredByIncidentId: options.triggeredByIncidentId || undefined,
+            triggeredByAlertId: options.triggeredByAlertId || undefined,
             onCallPolicyExecutionLogId: options.onCallPolicyExecutionLogId,
             onCallPolicyId: options.onCallPolicyId,
             onCallPolicyEscalationRuleId: ruleId,
@@ -220,7 +247,6 @@ export class Service extends DatabaseService<Model> {
             null,
           );
         } else {
-          // no users in this rule. Skipping.
           const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
           log.statusMessage =
             "Skipped because notification sent to this user already.";
@@ -247,7 +273,6 @@ export class Service extends DatabaseService<Model> {
         uniqueUserIds.push(userRule.userId!);
         await startUserNotificationRuleExecution(userRule.userId!, null, null);
       } else {
-        // no users in this rule. Skipping.
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage =
           "Skipped because notification sent to this user already.";
@@ -264,23 +289,16 @@ export class Service extends DatabaseService<Model> {
     }
 
     for (const scheduleRule of schedulesInRule) {
-      // get layers and users in this schedule and find a user to notify.
-
       const userIdInSchedule: ObjectID | null =
         await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
           scheduleRule.onCallDutyPolicyScheduleId!,
         );
 
       if (!userIdInSchedule) {
-        // no user active in this schedule. Skipping.
-
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
-
         log.statusMessage =
           "Skipped because no active users are found in this schedule.";
-
         log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
-
         log.onCallDutyScheduleId = scheduleRule.onCallDutyPolicyScheduleId!;
 
         await OnCallDutyPolicyExecutionLogTimelineService.create({
@@ -305,7 +323,6 @@ export class Service extends DatabaseService<Model> {
           scheduleRule.onCallDutyPolicyScheduleId!,
         );
       } else {
-        // no users in this rule. Skipping.
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage =
           "Skipped because notification sent to this user already.";
@@ -323,7 +340,6 @@ export class Service extends DatabaseService<Model> {
     }
 
     if (uniqueUserIds.length === 0) {
-      // no users in this rule. Skipping.
       const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
       log.statusMessage = "Skipped because no users in this rule.";
       log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
@@ -335,6 +351,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
     }
+
+    logger.debug(`Completed rule execution for ruleId: ${ruleId.toString()}`);
   }
 
   public constructor() {