@oneuptime/common 9.4.7 → 9.4.9

package/Server/Services/AlertGroupingRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AlertGroupingRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/AlertService.ts

@@ -54,6 +54,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import MetricType from "../../Models/DatabaseModels/MetricType";
 import Dictionary from "../../Types/Dictionary";
 import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
+import AlertGroupingEngineService from "./AlertGroupingEngineService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -351,6 +352,17 @@ export class Service extends DatabaseService<Model> {
         }
         return Promise.resolve();
       })
+      .then(async () => {
+        // Process alert for grouping into episodes
+        try {
+          await AlertGroupingEngineService.processAlert(createdItem);
+        } catch (error) {
+          logger.error(
+            `Alert grouping failed in AlertService.onCreateSuccess: ${error}`,
+          );
+          return Promise.resolve();
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in AlertService sequential operations: ${error}`,

package/Server/Services/CallService.ts

@@ -28,6 +28,7 @@ export class CallService extends BaseService {
       customTwilioConfig?: TwilioConfig | undefined;
       incidentId?: ObjectID | undefined;
       alertId?: ObjectID | undefined;
+      alertEpisodeId?: ObjectID | undefined;
       scheduledMaintenanceId?: ObjectID | undefined;
       statusPageId?: ObjectID | undefined;
       statusPageAnnouncementId?: ObjectID | undefined;
@@ -57,6 +58,7 @@ export class CallService extends BaseService {
         : undefined,
       incidentId: options.incidentId?.toString(),
       alertId: options.alertId?.toString(),
+      alertEpisodeId: options.alertEpisodeId?.toString(),
       scheduledMaintenanceId: options.scheduledMaintenanceId?.toString(),
       statusPageId: options.statusPageId?.toString(),
       statusPageAnnouncementId: options.statusPageAnnouncementId?.toString(),

package/Server/Services/Index.ts

@@ -158,6 +158,17 @@ import AlertOwnerTeamService from "./AlertOwnerTeamService";
 import AlertOwnerUserService from "./AlertOwnerUserService";
 import AlertSeverityService from "./AlertSeverityService";
 import AlertNoteTemplateService from "./AlertNoteTemplateService";
+
+// AlertEpisode Services
+import AlertEpisodeService from "./AlertEpisodeService";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import AlertEpisodeInternalNoteService from "./AlertEpisodeInternalNoteService";
+import AlertEpisodeMemberService from "./AlertEpisodeMemberService";
+import AlertEpisodeOwnerTeamService from "./AlertEpisodeOwnerTeamService";
+import AlertEpisodeOwnerUserService from "./AlertEpisodeOwnerUserService";
+import AlertEpisodeStateTimelineService from "./AlertEpisodeStateTimelineService";
+import AlertGroupingRuleService from "./AlertGroupingRuleService";
+
 import TableViewService from "./TableViewService";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import AlertFeedService from "./AlertFeedService";
@@ -351,6 +362,16 @@ const services: Array<BaseService> = [
   AlertNoteTemplateService,
   AlertFeedService,
 
+  // AlertEpisode Services
+  AlertEpisodeService,
+  AlertEpisodeFeedService,
+  AlertEpisodeInternalNoteService,
+  AlertEpisodeMemberService,
+  AlertEpisodeOwnerTeamService,
+  AlertEpisodeOwnerUserService,
+  AlertEpisodeStateTimelineService,
+  AlertGroupingRuleService,
+
   TableViewService,
   MonitorTestService,
 

package/Server/Services/MailService.ts

@@ -23,6 +23,7 @@ export class MailService extends BaseService {
       projectId?: ObjectID | undefined;
       incidentId?: ObjectID | undefined;
       alertId?: ObjectID | undefined;
+      alertEpisodeId?: ObjectID | undefined;
       scheduledMaintenanceId?: ObjectID | undefined;
       statusPageId?: ObjectID | undefined;
       statusPageAnnouncementId?: ObjectID | undefined;
@@ -68,6 +69,10 @@ export class MailService extends BaseService {
       body["alertId"] = options.alertId.toString();
     }
 
+    if (options?.alertEpisodeId) {
+      body["alertEpisodeId"] = options.alertEpisodeId.toString();
+    }
+
     if (options?.scheduledMaintenanceId) {
       body["scheduledMaintenanceId"] =
         options.scheduledMaintenanceId.toString();

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -110,6 +110,7 @@ export class Service extends DatabaseService<Model> {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
       triggeredByAlertId?: ObjectID | undefined;
+      triggeredByAlertEpisodeId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId: ObjectID;
       onCallPolicyId: ObjectID;
@@ -173,6 +174,10 @@ export class Service extends DatabaseService<Model> {
           log.triggeredByAlertId = options.triggeredByAlertId;
         }
 
+        if (options.triggeredByAlertEpisodeId) {
+          log.triggeredByAlertEpisodeId = options.triggeredByAlertEpisodeId;
+        }
+
         return log;
       };
 
@@ -192,7 +197,17 @@ export class Service extends DatabaseService<Model> {
       !options.triggeredByAlertId
     ) {
       throw new BadDataException(
-        "triggeredByAlertId is required when userNotificationEventType is IncidentCreated",
+        "triggeredByAlertId is required when userNotificationEventType is AlertCreated",
+      );
+    }
+
+    if (
+      UserNotificationEventType.AlertEpisodeCreated ===
+        options.userNotificationEventType &&
+      !options.triggeredByAlertEpisodeId
+    ) {
+      throw new BadDataException(
+        "triggeredByAlertEpisodeId is required when userNotificationEventType is AlertEpisodeCreated",
       );
     }
 
@@ -307,6 +322,8 @@ export class Service extends DatabaseService<Model> {
             userNotificationEventType: options.userNotificationEventType!,
             triggeredByIncidentId: options.triggeredByIncidentId || undefined,
             triggeredByAlertId: options.triggeredByAlertId || undefined,
+            triggeredByAlertEpisodeId:
+              options.triggeredByAlertEpisodeId || undefined,
             onCallPolicyExecutionLogId: options.onCallPolicyExecutionLogId,
             onCallPolicyId: options.onCallPolicyId,
             onCallPolicyEscalationRuleId: ruleId,

package/Server/Services/OnCallDutyPolicyExecutionLogService.ts

@@ -17,9 +17,12 @@ import ObjectID from "../../Types/ObjectID";
 import Color from "../../Types/Color";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
 import BadDataException from "../../Types/Exception/BadDataException";
 import IncidentService from "./IncidentService";
 import AlertService from "./AlertService";
+import AlertEpisodeService from "./AlertEpisodeService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -55,7 +58,11 @@ export class Service extends DatabaseService<Model> {
     _onCreate: OnCreate<Model>,
     createdItem: Model,
   ): Promise<Model> {
-    if (createdItem.triggeredByIncidentId || createdItem.triggeredByAlertId) {
+    if (
+      createdItem.triggeredByIncidentId ||
+      createdItem.triggeredByAlertId ||
+      createdItem.triggeredByAlertEpisodeId
+    ) {
       const onCallPolicy: OnCallDutyPolicy | null =
         await OnCallDutyPolicyService.findOneById({
           id: createdItem.onCallDutyPolicyId!,
@@ -90,6 +97,14 @@ export class Service extends DatabaseService<Model> {
           incidentOrAlertLink = `[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, createdItem.triggeredByAlertId)).toString()})`;
         }
 
+        if (createdItem.triggeredByAlertEpisodeId) {
+          const episodeNumber: number | null =
+            await AlertEpisodeService.getEpisodeNumber({
+              episodeId: createdItem.triggeredByAlertEpisodeId,
+            });
+          incidentOrAlertLink = `[Alert Episode ${episodeNumber}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(createdItem.projectId!, createdItem.triggeredByAlertEpisodeId)).toString()})`;
+        }
+
         const feedInfoInMarkdown: string = `**📞 On Call Policy Started Executing:** On Call Policy **${onCallPolicy.name}** started executing for ${incidentOrAlertLink}. Users on call on this policy will now be notified.`;
 
         if (
@@ -118,6 +133,20 @@ export class Service extends DatabaseService<Model> {
             feedInfoInMarkdown: feedInfoInMarkdown,
           });
         }
+
+        if (
+          onCallPolicy &&
+          onCallPolicy.id &&
+          createdItem.triggeredByAlertEpisodeId
+        ) {
+          await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+            alertEpisodeId: createdItem.triggeredByAlertEpisodeId,
+            projectId: createdItem.projectId!,
+            alertEpisodeFeedEventType: AlertEpisodeFeedEventType.OnCallPolicy,
+            displayColor: Yellow500,
+            feedInfoInMarkdown: feedInfoInMarkdown,
+          });
+        }
       }
     }
 
@@ -159,6 +188,11 @@ export class Service extends DatabaseService<Model> {
         userNotificationEventType = UserNotificationEventType.AlertCreated;
       }
 
+      if (createdItem.triggeredByAlertEpisodeId) {
+        userNotificationEventType =
+          UserNotificationEventType.AlertEpisodeCreated;
+      }
+
       if (!userNotificationEventType) {
         throw new BadDataException("Invalid userNotificationEventType");
       }
@@ -169,6 +203,7 @@ export class Service extends DatabaseService<Model> {
           projectId: createdItem.projectId!,
           triggeredByIncidentId: createdItem.triggeredByIncidentId,
           triggeredByAlertId: createdItem.triggeredByAlertId,
+          triggeredByAlertEpisodeId: createdItem.triggeredByAlertEpisodeId,
           userNotificationEventType: userNotificationEventType,
           onCallPolicyExecutionLogId: createdItem.id!,
           onCallPolicyId: createdItem.onCallDutyPolicyId!,
@@ -256,6 +291,7 @@ export class Service extends DatabaseService<Model> {
             statusMessage: true,
             triggeredByIncidentId: true,
             triggeredByAlertId: true,
+            triggeredByAlertEpisodeId: true,
           },
           props: {
             isRoot: true,
@@ -266,7 +302,8 @@ export class Service extends DatabaseService<Model> {
       if (
         onCalldutyPolicyExecutionLog &&
         (onCalldutyPolicyExecutionLog.triggeredByIncidentId ||
-          onCalldutyPolicyExecutionLog.triggeredByAlertId)
+          onCalldutyPolicyExecutionLog.triggeredByAlertId ||
+          onCalldutyPolicyExecutionLog.triggeredByAlertEpisodeId)
       ) {
         const onCallPolicy: OnCallDutyPolicy | null =
           await OnCallDutyPolicyService.findOneById({
@@ -308,6 +345,15 @@ export class Service extends DatabaseService<Model> {
             incidentOrAlertLink = `[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(onCalldutyPolicyExecutionLog.projectId!, onCalldutyPolicyExecutionLog.triggeredByAlertId)).toString()})`;
           }
 
+          if (onCalldutyPolicyExecutionLog.triggeredByAlertEpisodeId) {
+            const episodeNumber: number | null =
+              await AlertEpisodeService.getEpisodeNumber({
+                episodeId:
+                  onCalldutyPolicyExecutionLog.triggeredByAlertEpisodeId,
+              });
+            incidentOrAlertLink = `[Alert Episode ${episodeNumber}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(onCalldutyPolicyExecutionLog.projectId!, onCalldutyPolicyExecutionLog.triggeredByAlertEpisodeId)).toString()})`;
+          }
+
           const feedInfoInMarkdown: string = `**${this.getEmojiByStatus(onCalldutyPolicyExecutionLog.status)} On Call Policy Status Updated for ${incidentOrAlertLink}:**
 
  On-call policy **[${onCallPolicy.name?.toString()}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(onCallPolicy.projectId!, onCallPolicy.id!)).toString()})** status updated to **${onCalldutyPolicyExecutionLog.status}**`;
@@ -344,6 +390,22 @@ export class Service extends DatabaseService<Model> {
               feedInfoInMarkdown: feedInfoInMarkdown,
             });
           }
+
+          if (onCalldutyPolicyExecutionLog.triggeredByAlertEpisodeId) {
+            await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+              alertEpisodeId:
+                onCalldutyPolicyExecutionLog.triggeredByAlertEpisodeId,
+              projectId: onCalldutyPolicyExecutionLog.projectId!,
+              alertEpisodeFeedEventType: AlertEpisodeFeedEventType.OnCallPolicy,
+              displayColor: onCalldutyPolicyExecutionLog.status
+                ? this.getDisplayColorByStatus(
+                    onCalldutyPolicyExecutionLog.status,
+                  )
+                : Blue500,
+              moreInformationInMarkdown: moreInformationInMarkdown,
+              feedInfoInMarkdown: feedInfoInMarkdown,
+            });
+          }
         }
       }
     }

package/Server/Services/OnCallDutyPolicyExecutionLogTimelineService.ts

@@ -11,8 +11,11 @@ import logger from "../Utils/Logger";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import AlertService from "./AlertService";
+import AlertEpisodeService from "./AlertEpisodeService";
 import IncidentService from "./IncidentService";
 import UserService from "./UserService";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -80,6 +83,7 @@ export class Service extends DatabaseService<Model> {
           onCallDutyPolicyId: true,
           triggeredByIncidentId: true,
           triggeredByAlertId: true,
+          triggeredByAlertEpisodeId: true,
           projectId: true,
           status: true,
           statusMessage: true,
@@ -125,7 +129,8 @@ export class Service extends DatabaseService<Model> {
 
     if (
       !onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId &&
-      !onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId
+      !onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId &&
+      !onCallDutyPolicyExecutionLogTimeline.triggeredByAlertEpisodeId
     ) {
       return;
     }
@@ -172,6 +177,15 @@ export class Service extends DatabaseService<Model> {
           incidentOrAlertLink = `[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId)).toString()})`;
         }
 
+        if (onCallDutyPolicyExecutionLogTimeline.triggeredByAlertEpisodeId) {
+          const episodeNumber: number | null =
+            await AlertEpisodeService.getEpisodeNumber({
+              episodeId:
+                onCallDutyPolicyExecutionLogTimeline.triggeredByAlertEpisodeId,
+            });
+          incidentOrAlertLink = `[Alert Episode ${episodeNumber}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.triggeredByAlertEpisodeId)).toString()})`;
+        }
+
         let feedInfoInMarkdown: string = `**${this.getEmojiBasedOnStatus(status)} ${incidentOrAlertLink} On-Call Alert ${status} to ${await UserService.getUserMarkdownString(
           {
             userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
@@ -224,6 +238,18 @@ The on-call policy **[${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.na
           });
         }
 
+        if (onCallDutyPolicyExecutionLogTimeline.triggeredByAlertEpisodeId) {
+          await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+            alertEpisodeId:
+              onCallDutyPolicyExecutionLogTimeline.triggeredByAlertEpisodeId,
+            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+            alertEpisodeFeedEventType:
+              AlertEpisodeFeedEventType.OnCallNotification,
+            displayColor: displayColor,
+            feedInfoInMarkdown: feedInfoInMarkdown,
+          });
+        }
+
         logger.debug("Incident Feed created");
       }
     }

package/Server/Services/OnCallDutyPolicyService.ts

@@ -263,6 +263,7 @@ ${onCallPolicy.description || "No description provided."}
     options: {
       triggeredByIncidentId?: ObjectID | undefined;
       triggeredByAlertId?: ObjectID | undefined;
+      triggeredByAlertEpisodeId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
     },
   ): Promise<void> {
@@ -284,7 +285,17 @@ ${onCallPolicy.description || "No description provided."}
       !options.triggeredByAlertId
     ) {
       throw new BadDataException(
-        "triggeredByAlertId is required when userNotificationEventType is IncidentCreated",
+        "triggeredByAlertId is required when userNotificationEventType is AlertCreated",
+      );
+    }
+
+    if (
+      UserNotificationEventType.AlertEpisodeCreated ===
+        options.userNotificationEventType &&
+      !options.triggeredByAlertEpisodeId
+    ) {
+      throw new BadDataException(
+        "triggeredByAlertEpisodeId is required when userNotificationEventType is AlertEpisodeCreated",
       );
     }
 
@@ -323,6 +334,10 @@ ${onCallPolicy.description || "No description provided."}
       log.triggeredByAlertId = options.triggeredByAlertId;
     }
 
+    if (options.triggeredByAlertEpisodeId) {
+      log.triggeredByAlertEpisodeId = options.triggeredByAlertEpisodeId;
+    }
+
     await OnCallDutyPolicyExecutionLogService.create({
       data: log,
       props: {

package/Server/Services/PushNotificationService.ts

@@ -25,6 +25,7 @@ export interface PushNotificationOptions {
   // Optional relations for richer logging
   incidentId?: ObjectID | undefined;
   alertId?: ObjectID | undefined;
+  alertEpisodeId?: ObjectID | undefined;
   scheduledMaintenanceId?: ObjectID | undefined;
   statusPageId?: ObjectID | undefined;
   statusPageAnnouncementId?: ObjectID | undefined;

package/Server/Services/SmsService.ts

@@ -28,6 +28,7 @@ export class SmsService extends BaseService {
       customTwilioConfig?: TwilioConfig | undefined;
       incidentId?: ObjectID | undefined;
       alertId?: ObjectID | undefined;
+      alertEpisodeId?: ObjectID | undefined;
       scheduledMaintenanceId?: ObjectID | undefined;
       statusPageId?: ObjectID | undefined;
       statusPageAnnouncementId?: ObjectID | undefined;
@@ -58,6 +59,7 @@ export class SmsService extends BaseService {
         : undefined,
       incidentId: options.incidentId?.toString(),
       alertId: options.alertId?.toString(),
+      alertEpisodeId: options.alertEpisodeId?.toString(),
       scheduledMaintenanceId: options.scheduledMaintenanceId?.toString(),
       statusPageId: options.statusPageId?.toString(),
       statusPageAnnouncementId: options.statusPageAnnouncementId?.toString(),