@oneuptime/common 9.4.8 → 9.4.9

package/Server/Services/AlertEpisodeService.ts

@@ -18,7 +18,12 @@ import { IsBillingEnabled } from "../EnvironmentConfig";
 import OneUptimeDate from "../../Types/Date";
 import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
 import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
-import { Red500, Green500, Yellow500 } from "../../Types/BrandColors";
+import {
+  Red500,
+  Green500,
+  Yellow500,
+  Purple500,
+} from "../../Types/BrandColors";
 import URL from "../../Types/API/URL";
 import DatabaseConfig from "../DatabaseConfig";
 import AlertSeverityService from "./AlertSeverityService";
@@ -36,6 +41,9 @@ import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import Typeof from "../../Types/Typeof";
 import AlertService from "./AlertService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
+import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -57,7 +65,7 @@ export class Service extends DatabaseService<Model> {
         episodeNumber: true,
       },
       sort: {
-        createdAt: SortOrder.Descending,
+        episodeNumber: SortOrder.Descending,
       },
       props: {
         isRoot: true,
@@ -200,6 +208,16 @@ export class Service extends DatabaseService<Model> {
           );
         }
       })
+      .then(async () => {
+        // Execute on-call duty policies
+        try {
+          await this.executeEpisodeOnCallDutyPoliciesAsync(createdItem);
+        } catch (error) {
+          logger.error(
+            `On-call duty policy execution failed in AlertEpisodeService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in AlertEpisodeService.onCreateSuccess: ${error}`,
@@ -239,6 +257,93 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  @CaptureSpan()
+  private async executeEpisodeOnCallDutyPoliciesAsync(
+    createdItem: Model,
+  ): Promise<void> {
+    if (!createdItem.id || !createdItem.projectId) {
+      return;
+    }
+
+    try {
+      // Fetch the episode with on-call duty policies since they may not be loaded
+      const episodeWithPolicies: Model | null = await this.findOneById({
+        id: createdItem.id,
+        select: {
+          onCallDutyPolicies: {
+            _id: true,
+            name: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (
+        !episodeWithPolicies?.onCallDutyPolicies?.length ||
+        episodeWithPolicies.onCallDutyPolicies.length === 0
+      ) {
+        return;
+      }
+
+      // Execute all on-call policies in parallel
+      const policyPromises: Promise<void>[] =
+        episodeWithPolicies.onCallDutyPolicies.map(
+          (policy: OnCallDutyPolicy) => {
+            return OnCallDutyPolicyService.executePolicy(
+              new ObjectID(policy._id as string),
+              {
+                triggeredByAlertEpisodeId: createdItem.id!,
+                userNotificationEventType:
+                  UserNotificationEventType.AlertEpisodeCreated,
+              },
+            );
+          },
+        );
+
+      await Promise.allSettled(policyPromises);
+
+      // Update the flag to indicate on-call policy has been executed
+      await this.updateOneById({
+        id: createdItem.id,
+        data: {
+          isOnCallPolicyExecuted: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // Create feed entry for on-call policy execution
+      const policyNames: string[] = episodeWithPolicies.onCallDutyPolicies
+        .map((policy: OnCallDutyPolicy) => {
+          return policy.name || "Unnamed Policy";
+        })
+        .filter((name: string) => {
+          return Boolean(name);
+        });
+
+      let feedInfoInMarkdown: string = `#### On-Call Policy Executed\n\n`;
+      feedInfoInMarkdown += `The following on-call ${policyNames.length === 1 ? "policy has" : "policies have"} been executed for this episode:\n\n`;
+
+      for (const policyName of policyNames) {
+        feedInfoInMarkdown += `- ${policyName}\n`;
+      }
+
+      await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+        alertEpisodeId: createdItem.id,
+        projectId: createdItem.projectId,
+        alertEpisodeFeedEventType: AlertEpisodeFeedEventType.OnCallPolicy,
+        displayColor: Purple500,
+        feedInfoInMarkdown: feedInfoInMarkdown,
+      });
+    } catch (error) {
+      logger.error(`Error in executeEpisodeOnCallDutyPoliciesAsync: ${error}`);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   public async changeEpisodeState(data: {
     projectId: ObjectID;
@@ -304,28 +409,10 @@ export class Service extends DatabaseService<Model> {
       props: props || {},
     });
 
-    // Update resolved timestamp if this is a resolved state
-    const alertState: AlertState | null = await AlertStateService.findOneById({
-      id: alertStateId,
-      select: {
-        isResolvedState: true,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
-
-    if (alertState?.isResolvedState) {
-      await this.updateOneById({
-        id: episodeId,
-        data: {
-          resolvedAt: OneUptimeDate.getCurrentDate(),
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-    }
+    /*
+     * Note: resolvedAt is updated by AlertEpisodeStateTimelineService.onCreateSuccess()
+     * to avoid duplicate updates.
+     */
 
     // Cascade state change to all member alerts if requested
     if (cascadeToAlerts) {
@@ -395,7 +482,7 @@ export class Service extends DatabaseService<Model> {
   @CaptureSpan()
   public async acknowledgeEpisode(
     episodeId: ObjectID,
-    acknowledgedByUserId: ObjectID,
+    acknowledgedByUserId?: ObjectID,
     cascadeToAlerts: boolean = true,
   ): Promise<void> {
     const episode: Model | null = await this.findOneById({
@@ -463,7 +550,7 @@ export class Service extends DatabaseService<Model> {
   @CaptureSpan()
   public async resolveEpisode(
     episodeId: ObjectID,
-    resolvedByUserId: ObjectID,
+    resolvedByUserId?: ObjectID,
     cascadeToAlerts: boolean = true,
   ): Promise<void> {
     const episode: Model | null = await this.findOneById({
@@ -809,6 +896,27 @@ export class Service extends DatabaseService<Model> {
     );
   }
 
+  @CaptureSpan()
+  public async getEpisodeNumber(data: {
+    episodeId: ObjectID;
+  }): Promise<number | null> {
+    const episode: Model | null = await this.findOneById({
+      id: data.episodeId,
+      select: {
+        episodeNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!episode) {
+      throw new BadDataException("Episode not found.");
+    }
+
+    return episode.episodeNumber ? Number(episode.episodeNumber) : null;
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,

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

@@ -285,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",
       );
     }
 

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;