@oneuptime/common 11.3.21 → 11.3.23

package/Server/Services/IncidentService.ts

@@ -56,6 +56,8 @@ import logger, { LogAttributes } from "../Utils/Logger";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentSlaService from "./IncidentSlaService";
+import IncidentReminderRuleService from "./IncidentReminderRuleService";
+import IncidentReminderRule from "../../Models/DatabaseModels/IncidentReminderRule";
 import { setIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import IncidentGroupingEngineService from "./IncidentGroupingEngineService";
@@ -230,6 +232,64 @@ export class Service extends DatabaseService<Model> {
     return false;
   }
 
+  @CaptureSpan()
+  public async refreshReminderSchedule(data: {
+    incidentId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<void> {
+    const incident: Model | null = await this.findOneById({
+      id: data.incidentId,
+      select: {
+        enableReminders: true,
+        incidentSeverityId: true,
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      return;
+    }
+
+    let nextReminderNotificationAt: Date | null = null;
+
+    if (incident.enableReminders !== false) {
+      const matchingRule: IncidentReminderRule | null =
+        await IncidentReminderRuleService.findMatchingRule({
+          projectId: data.projectId,
+          incidentSeverityId: incident.incidentSeverityId,
+          labelIds: incident.labels?.map((label: Label) => {
+            return label.id!;
+          }),
+        });
+
+      if (
+        matchingRule &&
+        matchingRule.reminderIntervalInMinutes &&
+        !(await this.isIncidentResolved({ incidentId: data.incidentId }))
+      ) {
+        nextReminderNotificationAt = OneUptimeDate.addRemoveMinutes(
+          OneUptimeDate.getCurrentDate(),
+          matchingRule.reminderIntervalInMinutes,
+        );
+      }
+    }
+
+    await this.updateOneById({
+      id: data.incidentId,
+      data: {
+        nextReminderNotificationAt: nextReminderNotificationAt,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   @CaptureSpan()
   public async resolveIncident(
     incidentId: ObjectID,
@@ -1161,6 +1221,26 @@ export class Service extends DatabaseService<Model> {
           );
         }
       })
+      .then(async () => {
+        // Schedule reminder notifications for incident if a matching reminder rule exists
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            await this.refreshReminderSchedule({
+              incidentId: createdItem.id,
+              projectId: createdItem.projectId,
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `Reminder scheduling failed in IncidentService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              incidentId: createdItem.id?.toString(),
+              userId: createdItem.createdByUserId?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in IncidentService sequential operations: ${error}`,
@@ -1728,6 +1808,29 @@ ${incident.remediationNotes || "No remediation notes provided."}
           });
         }
 
+        // Re-evaluate reminder schedule when reminders are enabled or disabled for this incident
+        if (
+          Object.prototype.hasOwnProperty.call(
+            updatedIncidentData,
+            "enableReminders",
+          )
+        ) {
+          try {
+            await this.refreshReminderSchedule({
+              incidentId: incidentId,
+              projectId: projectId,
+            });
+          } catch (reminderError) {
+            logger.error(
+              `Reminder rescheduling failed in IncidentService.onUpdateSuccess: ${reminderError}`,
+              {
+                projectId: projectId?.toString(),
+                incidentId: incidentId?.toString(),
+              } as LogAttributes,
+            );
+          }
+        }
+
         // emit postmortem completion time metric when postmortemPostedAt is set
         if (
           Object.prototype.hasOwnProperty.call(
@@ -1976,6 +2079,30 @@ ${labels
           }
         }
 
+        /*
+         * Re-match reminder rule on any labels change (including clearing all
+         * labels), since labels can change which reminder rule matches.
+         */
+        if (
+          updatedIncidentData.labels &&
+          Array.isArray(updatedIncidentData.labels)
+        ) {
+          try {
+            await this.refreshReminderSchedule({
+              incidentId: incidentId,
+              projectId: projectId,
+            });
+          } catch (reminderError) {
+            logger.error(
+              `Reminder rescheduling failed in IncidentService.onUpdateSuccess: ${reminderError}`,
+              {
+                projectId: projectId?.toString(),
+                incidentId: incidentId?.toString(),
+              } as LogAttributes,
+            );
+          }
+        }
+
         if (
           updatedIncidentData.incidentSeverity &&
           (updatedIncidentData.incidentSeverity as any)._id
@@ -2017,6 +2144,22 @@ ${incidentSeverity.name}
               );
             }
 
+            // Re-match reminder rule when severity changes
+            try {
+              await this.refreshReminderSchedule({
+                incidentId: incidentId,
+                projectId: projectId,
+              });
+            } catch (reminderError) {
+              logger.error(
+                `Reminder rescheduling failed in IncidentService.onUpdateSuccess: ${reminderError}`,
+                {
+                  projectId: projectId?.toString(),
+                  incidentId: incidentId?.toString(),
+                } as LogAttributes,
+              );
+            }
+
             // emit severity change metric
             try {
               const severityChangeMetric: MutableMetric = new MutableMetric();

package/Server/Services/Index.ts

@@ -226,6 +226,9 @@ import IncidentEpisodePublicNoteService from "./IncidentEpisodePublicNoteService
 import AlertGroupingRuleService from "./AlertGroupingRuleService";
 import IncidentSlaRuleService from "./IncidentSlaRuleService";
 import IncidentSlaService from "./IncidentSlaService";
+import IncidentReminderRuleService from "./IncidentReminderRuleService";
+import AlertReminderRuleService from "./AlertReminderRuleService";
+import ScheduledMaintenanceReminderRuleService from "./ScheduledMaintenanceReminderRuleService";
 
 import TableViewService from "./TableViewService";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
@@ -481,6 +484,9 @@ const services: Array<BaseService> = [
   AlertGroupingRuleService,
   IncidentSlaRuleService,
   IncidentSlaService,
+  IncidentReminderRuleService,
+  AlertReminderRuleService,
+  ScheduledMaintenanceReminderRuleService,
 
   TableViewService,
   MonitorTestService,

package/Server/Services/ScheduledMaintenanceReminderRuleService.ts

@@ -0,0 +1,236 @@
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ScheduledMaintenanceReminderRule";
+import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
+import Label from "../../Models/DatabaseModels/Label";
+import ScheduledMaintenanceState from "../../Models/DatabaseModels/ScheduledMaintenanceState";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
+import ScheduledMaintenanceStateService from "./ScheduledMaintenanceStateService";
+import QueryHelper from "../Types/Database/QueryHelper";
+import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    // Auto-assign order on creation
+    if (!createBy.data.order) {
+      const highestOrderRule: Model | null = await this.findOneBy({
+        query: {
+          projectId: createBy.data.projectId!,
+        },
+        select: {
+          order: true,
+        },
+        sort: {
+          order: SortOrder.Descending,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      createBy.data.order = (highestOrderRule?.order || 0) + 1;
+    }
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (createdItem.projectId) {
+      await this.refreshSchedulesForOpenScheduledMaintenances(
+        createdItem.projectId,
+      );
+    }
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  protected override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    const projectId: ObjectID | undefined = onUpdate.updateBy.props.tenantId as
+      | ObjectID
+      | undefined;
+
+    if (projectId) {
+      await this.refreshSchedulesForOpenScheduledMaintenances(projectId);
+    }
+
+    return onUpdate;
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const projectId: ObjectID | undefined = onDelete.deleteBy.props.tenantId as
+      | ObjectID
+      | undefined;
+
+    if (projectId) {
+      await this.refreshSchedulesForOpenScheduledMaintenances(projectId);
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public async refreshSchedulesForOpenScheduledMaintenances(
+    projectId: ObjectID,
+  ): Promise<void> {
+    try {
+      const openStates: Array<ScheduledMaintenanceState> =
+        await ScheduledMaintenanceStateService.findBy({
+          query: {
+            projectId: projectId,
+            isResolvedState: false,
+          },
+          select: {
+            _id: true,
+          },
+          limit: LIMIT_PER_PROJECT,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      const openStateIds: Array<ObjectID> = openStates
+        .map((state: ScheduledMaintenanceState) => {
+          return state.id!;
+        })
+        .filter(Boolean);
+
+      if (openStateIds.length === 0) {
+        return;
+      }
+
+      const openScheduledMaintenances: Array<ScheduledMaintenance> =
+        await ScheduledMaintenanceService.findBy({
+          query: {
+            projectId: projectId,
+            currentScheduledMaintenanceStateId: QueryHelper.any(openStateIds),
+          },
+          select: {
+            _id: true,
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      for (const scheduledMaintenance of openScheduledMaintenances) {
+        try {
+          await ScheduledMaintenanceService.refreshReminderSchedule({
+            scheduledMaintenanceId: scheduledMaintenance.id!,
+            projectId: projectId,
+          });
+        } catch (error) {
+          logger.error(
+            `Failed to refresh reminder schedule for scheduled maintenance ${scheduledMaintenance.id}: ${error}`,
+            { projectId: projectId?.toString() } as LogAttributes,
+          );
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `Failed to refresh reminder schedules for open scheduled maintenances: ${error}`,
+        { projectId: projectId?.toString() } as LogAttributes,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  public async findMatchingRule(data: {
+    projectId: ObjectID;
+    labelIds?: Array<ObjectID> | undefined;
+  }): Promise<Model | null> {
+    // Get all enabled rules sorted by order. First matching rule wins.
+    const rules: Array<Model> = await this.findBy({
+      query: {
+        projectId: data.projectId,
+        isEnabled: true,
+      },
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      select: {
+        _id: true,
+        name: true,
+        order: true,
+        reminderIntervalInMinutes: true,
+        stopRemindersOnState: true,
+        remindWhileScheduled: true,
+        labels: {
+          _id: true,
+        },
+      },
+      limit: 100,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const rule of rules) {
+      if (rule.labels && rule.labels.length > 0) {
+        if (!data.labelIds || data.labelIds.length === 0) {
+          continue;
+        }
+
+        const ruleLabelIds: Array<string> = rule.labels.map((label: Label) => {
+          return label.id?.toString() || "";
+        });
+
+        const hasMatchingLabel: boolean = data.labelIds.some(
+          (labelId: ObjectID) => {
+            return ruleLabelIds.includes(labelId.toString());
+          },
+        );
+
+        if (!hasMatchingLabel) {
+          continue;
+        }
+      }
+
+      // Rule with no labels matches all scheduled maintenances.
+      logger.debug(
+        `Scheduled maintenance reminder rule ${rule.name || rule.id} matched for project ${data.projectId}`,
+        { projectId: data.projectId?.toString() } as LogAttributes,
+      );
+
+      return rule;
+    }
+
+    return null;
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceService.ts

@@ -8,6 +8,8 @@ import ScheduledMaintenanceOwnerTeamService from "./ScheduledMaintenanceOwnerTea
 import ScheduledMaintenanceOwnerUserService from "./ScheduledMaintenanceOwnerUserService";
 import ScheduledMaintenanceStateService from "./ScheduledMaintenanceStateService";
 import ScheduledMaintenanceStateTimelineService from "./ScheduledMaintenanceStateTimelineService";
+import ScheduledMaintenanceReminderRuleService from "./ScheduledMaintenanceReminderRuleService";
+import ScheduledMaintenanceReminderRule from "../../Models/DatabaseModels/ScheduledMaintenanceReminderRule";
 import TeamMemberService from "./TeamMemberService";
 import URL from "../../Types/API/URL";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
@@ -809,6 +811,80 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
     return { createBy, carryForward: null };
   }
 
+  @CaptureSpan()
+  public async refreshReminderSchedule(data: {
+    scheduledMaintenanceId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<void> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: data.scheduledMaintenanceId,
+      select: {
+        enableReminders: true,
+        startsAt: true,
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      return;
+    }
+
+    let nextReminderNotificationAt: Date | null = null;
+
+    if (scheduledMaintenance.enableReminders !== false) {
+      const matchingRule: ScheduledMaintenanceReminderRule | null =
+        await ScheduledMaintenanceReminderRuleService.findMatchingRule({
+          projectId: data.projectId,
+          labelIds: scheduledMaintenance.labels?.map((label: Label) => {
+            return label.id!;
+          }),
+        });
+
+      if (
+        matchingRule &&
+        matchingRule.reminderIntervalInMinutes &&
+        !(await this.isScheduledMaintenanceCompleted({
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        }))
+      ) {
+        /*
+         * When the rule does not remind while the event is still scheduled,
+         * defer the first reminder until after the event has started so that
+         * owners are not notified about an event that has not begun yet.
+         */
+        let referenceDate: Date = OneUptimeDate.getCurrentDate();
+
+        if (
+          !matchingRule.remindWhileScheduled &&
+          scheduledMaintenance.startsAt &&
+          OneUptimeDate.isInTheFuture(scheduledMaintenance.startsAt)
+        ) {
+          referenceDate = scheduledMaintenance.startsAt;
+        }
+
+        nextReminderNotificationAt = OneUptimeDate.addRemoveMinutes(
+          referenceDate,
+          matchingRule.reminderIntervalInMinutes,
+        );
+      }
+    }
+
+    await this.updateOneById({
+      id: data.scheduledMaintenanceId,
+      data: {
+        nextReminderNotificationAt: nextReminderNotificationAt,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     onCreate: OnCreate<Model>,
@@ -985,6 +1061,26 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
           );
         }
       })
+      .then(async () => {
+        // Schedule reminder notifications for scheduled maintenance if a matching reminder rule exists
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            await this.refreshReminderSchedule({
+              scheduledMaintenanceId: createdItem.id,
+              projectId: createdItem.projectId,
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `Reminder scheduling failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              scheduledMaintenanceId: createdItem.id?.toString(),
+              userId: createdItem.createdByUserId?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in ScheduledMaintenanceService sequential operations: ${error}`,
@@ -1577,6 +1673,37 @@ ${labels
             },
           );
         }
+
+        /*
+         * Re-evaluate reminder schedule when reminders are enabled or disabled,
+         * or when labels change (which may change the matching reminder rule).
+         */
+        if (
+          onUpdate.updateBy.props.tenantId &&
+          (Object.prototype.hasOwnProperty.call(
+            onUpdate.updateBy.data,
+            "enableReminders",
+          ) ||
+            Object.prototype.hasOwnProperty.call(
+              onUpdate.updateBy.data,
+              "labels",
+            ))
+        ) {
+          try {
+            await this.refreshReminderSchedule({
+              scheduledMaintenanceId: scheduledMaintenanceId,
+              projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            });
+          } catch (reminderError) {
+            logger.error(
+              `Reminder rescheduling failed in ScheduledMaintenanceService.onUpdateSuccess: ${reminderError}`,
+              {
+                projectId: onUpdate.updateBy.props.tenantId?.toString(),
+                scheduledMaintenanceId: scheduledMaintenanceId?.toString(),
+              } as LogAttributes,
+            );
+          }
+        }
       }
     }