@oneuptime/common 7.0.3786 → 7.0.3822

package/Server/Services/AlertService.ts

@@ -47,6 +47,10 @@ import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import AlertWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/Alert";
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import MonitorService from "./MonitorService";
+import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -260,46 +264,125 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("currentAlertStateId is required");
     }
 
+    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,
+        },
+        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;
 
-    await AlertFeedService.createAlertFeedItem({
-      alertId: createdItem.id!,
-      projectId: createdItem.projectId!,
-      alertFeedEventType: AlertFeedEventType.AlertCreated,
-      displayColor: Red500,
-      feedInfoInMarkdown: `**Alert #${createdItem.alertNumber?.toString()} Created**:
-          
-  **Alert Title**:
-  
-  ${createdItem.title || "No title provided."}
-  
-  **Description**:
-  
-  ${createdItem.description || "No description provided."}
-    
-          `,
-      userId: createdByUserId || undefined,
-    });
+    // send message to workspaces - slack, teams,   etc.
+    const workspaceResult: {
+      channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+    } | null =
+      await AlertWorkspaceMessages.createChannelsAndInviteUsersToChannels({
+        projectId: createdItem.projectId,
+        alertId: createdItem.id!,
+        alertNumber: createdItem.alertNumber!,
+      });
 
-    await AlertFeedService.createAlertFeedItem({
-      alertId: createdItem.id!,
-      projectId: createdItem.projectId!,
-      alertFeedEventType: AlertFeedEventType.RootCause,
-      displayColor: Red500,
-      feedInfoInMarkdown: `**Root Cause**
-        
-${createdItem.rootCause || "No root cause provided."}`,
-    });
+    logger.debug("Alert created. Workspace result:");
+    logger.debug(workspaceResult);
+
+    if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+      // update alert with these channels.
+      await this.updateOneById({
+        id: createdItem.id!,
+        data: {
+          postUpdatesToWorkspaceChannels: workspaceResult.channelsCreated || [],
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    let feedInfoInMarkdown: string = `#### 🚨 Alert ${createdItem.alertNumber?.toString()} Created: 
+         
+**${createdItem.title || "No title provided."}**:
+   
+${createdItem.description || "No description provided."}
+   
+   `;
+
+    if (alert.currentAlertState?.name) {
+      feedInfoInMarkdown += `🔴 **Alert State**: ${alert.currentAlertState.name} \n\n`;
+    }
+
+    if (alert.alertSeverity?.name) {
+      feedInfoInMarkdown += `⚠️ **Severity**: ${alert.alertSeverity.name} \n\n`;
+    }
+
+    if (alert.monitor) {
+      feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
+
+      const monitor: Monitor = alert.monitor;
+      feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(createdItem.projectId!, monitor.id!)).toString()})\n`;
+
+      feedInfoInMarkdown += `\n\n`;
+    }
+
+    if (createdItem.rootCause) {
+      feedInfoInMarkdown += `\n
+📄 **Root Cause**:
+   
+${createdItem.rootCause || "No root cause provided."}
+   
+`;
+    }
+
+    if (createdItem.remediationNotes) {
+      feedInfoInMarkdown += `\n 
+🎯 **Remediation Notes**:
+   
+${createdItem.remediationNotes || "No remediation notes provided."}
+   
+   
+   `;
+    }
+
+    const alertCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await AlertWorkspaceMessages.getAlertCreateMessageBlocks({
+        alertId: createdItem.id!,
+        projectId: createdItem.projectId!,
+      });
 
     await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.id!,
       projectId: createdItem.projectId!,
-      alertFeedEventType: AlertFeedEventType.RemediationNotes,
+      alertFeedEventType: AlertFeedEventType.AlertCreated,
       displayColor: Red500,
-      feedInfoInMarkdown: `**Remediation Notes**
-        
-${createdItem.remediationNotes || "No remediation notes provided."}`,
+      feedInfoInMarkdown: feedInfoInMarkdown,
+      userId: createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: alertCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
     });
 
     await this.changeAlertState({
@@ -366,7 +449,7 @@ ${createdItem.remediationNotes || "No remediation notes provided."}`,
     });
 
     if (!alert) {
-      throw new BadDataException("Incident not found.");
+      throw new BadDataException("Alert not found.");
     }
 
     return (alert.postUpdatesToWorkspaceChannels || []).filter(
@@ -555,7 +638,22 @@ ${createdItem.remediationNotes || "No remediation notes provided."}`,
     if (updatedItemIds.length > 0) {
       for (const alertId of updatedItemIds) {
         let shouldAddAlertFeed: boolean = false;
-        let feedInfoInMarkdown: string = "**Alert was updated.**";
+
+        const alert: Model | null = await this.findOneById({
+          id: alertId,
+          select: {
+            projectId: true,
+            alertNumber: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        const projectId: ObjectID = alert!.projectId!;
+        const alertNumber: number = alert!.alertNumber!;
+
+        let feedInfoInMarkdown: string = `**[Alert ${alertNumber}](${(await this.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) was updated.**`;
 
         const createdByUserId: ObjectID | undefined | null =
           onUpdate.updateBy.props.userId;
@@ -573,7 +671,7 @@ ${onUpdate.updateBy.data.title || "No title provided."}
           if (onUpdate.updateBy.data.title) {
             // add alert feed.
 
-            feedInfoInMarkdown += `\n\n**Root Cause**: 
+            feedInfoInMarkdown += `\n\n**📄 Root Cause**: 
 ${onUpdate.updateBy.data.rootCause || "No root cause provided."}
   `;
             shouldAddAlertFeed = true;
@@ -592,7 +690,7 @@ ${onUpdate.updateBy.data.rootCause || "No root cause provided."}
         if (onUpdate.updateBy.data.remediationNotes) {
           // add alert feed.
 
-          feedInfoInMarkdown += `\n\n**Remediation Notes**: 
+          feedInfoInMarkdown += `\n\n**🎯 Remediation Notes**: 
 ${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
         `;
           shouldAddAlertFeed = true;
@@ -632,7 +730,7 @@ ${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
           });
 
           if (labels.length > 0) {
-            feedInfoInMarkdown += `\n\n**Labels**:
+            feedInfoInMarkdown += `\n\n**🏷️ Labels**:
 
 ${labels
   .map((label: Label) => {
@@ -665,7 +763,7 @@ ${labels
             });
 
           if (alertSeverity) {
-            feedInfoInMarkdown += `\n\n**Alert Severity**:
+            feedInfoInMarkdown += `\n\n**⚠️ Alert Severity**:
 ${alertSeverity.name}
 `;
 
@@ -681,6 +779,9 @@ ${alertSeverity.name}
             displayColor: Gray500,
             feedInfoInMarkdown: feedInfoInMarkdown,
             userId: createdByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+            },
           });
         }
       }
@@ -1076,6 +1177,48 @@ ${alertSeverity.name}
     });
   }
 
+  public async isAlertResolved(data: { alertId: ObjectID }): Promise<boolean> {
+    const alert: Model | null = await this.findOneBy({
+      query: {
+        _id: data.alertId,
+      },
+      select: {
+        projectId: true,
+        currentAlertState: {
+          order: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!alert) {
+      throw new BadDataException("Alert not found");
+    }
+
+    if (!alert.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    const resolvedAlertState: AlertState =
+      await AlertStateService.getResolvedAlertState({
+        projectId: alert.projectId,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const currentAlertStateOrder: number = alert.currentAlertState!.order!;
+    const resolvedAlertStateOrder: number = resolvedAlertState.order!;
+
+    if (currentAlertStateOrder >= resolvedAlertStateOrder) {
+      return true;
+    }
+
+    return false;
+  }
+
   public async getAlertNumber(data: {
     alertId: ObjectID;
   }): Promise<number | null> {
@@ -1095,5 +1238,61 @@ ${alertSeverity.name}
 
     return alert.alertNumber || null;
   }
+
+  public async resolveAlert(
+    alertId: ObjectID,
+    resolvedByUserId: ObjectID,
+  ): Promise<Model> {
+    const alert: Model | null = await this.findOneById({
+      id: alertId,
+      select: {
+        projectId: true,
+        alertNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!alert || !alert.projectId) {
+      throw new BadDataException("Alert not found.");
+    }
+
+    const alertState: AlertState | null = await AlertStateService.findOneBy({
+      query: {
+        projectId: alert.projectId,
+        isResolvedState: true,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!alertState || !alertState.id) {
+      throw new BadDataException(
+        "Acknowledged state not found for this project. Please add acknowledged state from settings.",
+      );
+    }
+
+    const alertStateTimeline: AlertStateTimeline = new AlertStateTimeline();
+    alertStateTimeline.projectId = alert.projectId;
+    alertStateTimeline.alertId = alertId;
+    alertStateTimeline.alertStateId = alertState.id;
+    alertStateTimeline.createdByUserId = resolvedByUserId;
+
+    await AlertStateTimelineService.create({
+      data: alertStateTimeline,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // store alert metric
+
+    return alert;
+  }
 }
 export default new Service();

package/Server/Services/AlertStateService.ts

@@ -200,6 +200,30 @@ export class Service extends DatabaseService<AlertState> {
     return unresolvedAlertStates;
   }
 
+  public async getResolvedAlertState(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<AlertState> {
+    const alertStates: Array<AlertState> = await this.getAllAlertStates({
+      projectId: data.projectId,
+      props: data.props,
+    });
+
+    const resolvedAlertState: AlertState | undefined = alertStates.find(
+      (alertState: AlertState) => {
+        return alertState?.isResolvedState;
+      },
+    );
+
+    if (!resolvedAlertState) {
+      throw new BadDataException(
+        "Resolved Alert State not found for this project",
+      );
+    }
+
+    return resolvedAlertState;
+  }
+
   public async getAcknowledgedAlertState(data: {
     projectId: ObjectID;
     props: DatabaseCommonInteractionProps;

package/Server/Services/AlertStateTimelineService.ts

@@ -179,16 +179,44 @@ export class Service extends DatabaseService<AlertStateTimeline> {
     });
 
     const stateName: string = alertState?.name || "";
+    let stateEmoji: string = "➡️";
+
+    // if resolved state then change emoji to ✅.
+
+    if (alertState?.isResolvedState) {
+      stateEmoji = "✅";
+    } else if (alertState?.isAcknowledgedState) {
+      // eyes emoji for acknowledged state.
+      stateEmoji = "👀";
+    } else if (alertState?.isCreatedState) {
+      stateEmoji = "🔴";
+    }
+
+    const alertNumber: number | null = await AlertService.getAlertNumber({
+      alertId: createdItem.alertId,
+    });
+
+    const projectId: ObjectID = createdItem.projectId!;
+    const alertId: ObjectID = createdItem.alertId!;
 
     await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.alertId!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.AlertStateChanged,
       displayColor: alertState?.color,
-      feedInfoInMarkdown: "**Alert State** changed to **" + stateName + "**",
+      feedInfoInMarkdown:
+        stateEmoji +
+        ` Changed **[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) State** to **` +
+        stateName +
+        "**",
       moreInformationInMarkdown: `**Cause:** 
-${createdItem.rootCause}`,
+   ${createdItem.rootCause}`,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId:
+          createdItem.createdByUserId || onCreate.createBy.props.userId,
+      },
     });
 
     await AlertService.updateOneBy({

package/Server/Services/IncidentInternalNoteService.ts

@@ -20,14 +20,14 @@ export class Service extends DatabaseService<Model> {
     projectId: ObjectID;
     note: string;
   }): Promise<Model> {
-    const publicNote: Model = new Model();
-    publicNote.createdByUserId = data.userId;
-    publicNote.incidentId = data.incidentId;
-    publicNote.projectId = data.projectId;
-    publicNote.note = data.note;
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.incidentId = data.incidentId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
 
     return this.create({
-      data: publicNote,
+      data: internalNote,
       props: {
         isRoot: true,
       },

package/Server/Services/IncidentPublicNoteService.ts

@@ -9,6 +9,7 @@ import { Blue500, Indigo500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import IncidentService from "./IncidentService";
+import Incident from "../../Models/DatabaseModels/Incident";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -109,17 +110,19 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
+        const incident: Incident = updatedItem.incident!;
+
         await IncidentFeedService.createIncidentFeedItem({
           incidentId: updatedItem.incidentId!,
           projectId: updatedItem.projectId!,
-          incidentFeedEventType: IncidentFeedEventType.PublicNote,
+          incidentFeedEventType: IncidentFeedEventType.PrivateNote,
           displayColor: Blue500,
           userId: userId || undefined,
 
-          feedInfoInMarkdown: `📄 **Updated Public Note**
-  
+          feedInfoInMarkdown: `📄 updated **Public Note** for this [Incident ${incident.incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(incident.projectId!, incident.id!)).toString()})
+        
 ${updatedItem.note}
-            `,
+                  `,
           workspaceNotification: {
             sendWorkspaceNotification: true,
             notifyUserId: userId || undefined,

package/Server/Services/IncidentStateTimelineService.ts

@@ -221,7 +221,8 @@ ${createdItem.rootCause}`,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
       workspaceNotification: {
         sendWorkspaceNotification: true,
-        notifyUserId: createdItem.createdByUserId,
+        notifyUserId:
+          createdItem.createdByUserId || onCreate.createBy.props.userId,
       },
     });