@oneuptime/common 9.4.13 → 9.5.0

package/Server/Services/IncidentSlaService.ts

@@ -0,0 +1,550 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentSla";
+import IncidentSlaRule from "../../Models/DatabaseModels/IncidentSlaRule";
+import Incident from "../../Models/DatabaseModels/Incident";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import IncidentSlaStatus from "../../Types/Incident/IncidentSlaStatus";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import IncidentSlaRuleService from "./IncidentSlaRuleService";
+import IncidentService from "./IncidentService";
+import QueryHelper from "../Types/Database/QueryHelper";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  public async createSlaForIncident(data: {
+    incidentId: ObjectID;
+    projectId: ObjectID;
+    declaredAt: Date;
+    incident?: Incident;
+  }): Promise<Model | null> {
+    logger.debug(
+      `Creating SLA record for incident ${data.incidentId} in project ${data.projectId}`,
+    );
+
+    // Find matching rule
+    const matchingRuleArgs: {
+      incidentId: ObjectID;
+      projectId: ObjectID;
+      incident?: Incident;
+    } = {
+      incidentId: data.incidentId,
+      projectId: data.projectId,
+    };
+
+    if (data.incident) {
+      matchingRuleArgs.incident = data.incident;
+    }
+
+    const matchingRule: IncidentSlaRule | null =
+      await IncidentSlaRuleService.findMatchingRule(matchingRuleArgs);
+
+    if (!matchingRule || !matchingRule.id) {
+      logger.debug(
+        `No matching SLA rule found for incident ${data.incidentId}`,
+      );
+      return null;
+    }
+
+    // Calculate deadlines
+    const slaStartedAt: Date = data.declaredAt;
+    let responseDeadline: Date | undefined = undefined;
+    let resolutionDeadline: Date | undefined = undefined;
+
+    if (matchingRule.responseTimeInMinutes) {
+      responseDeadline = OneUptimeDate.addRemoveMinutes(
+        slaStartedAt,
+        matchingRule.responseTimeInMinutes,
+      );
+    }
+
+    if (matchingRule.resolutionTimeInMinutes) {
+      resolutionDeadline = OneUptimeDate.addRemoveMinutes(
+        slaStartedAt,
+        matchingRule.resolutionTimeInMinutes,
+      );
+    }
+
+    // Create SLA record
+    const sla: Model = new Model();
+    sla.projectId = data.projectId;
+    sla.incidentId = data.incidentId;
+    sla.incidentSlaRuleId = matchingRule.id;
+    sla.slaStartedAt = slaStartedAt;
+    sla.status = IncidentSlaStatus.OnTrack;
+
+    if (responseDeadline) {
+      sla.responseDeadline = responseDeadline;
+    }
+
+    if (resolutionDeadline) {
+      sla.resolutionDeadline = resolutionDeadline;
+    }
+
+    try {
+      const createdSla: Model = await this.create({
+        data: sla,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      logger.info(
+        `Created SLA record ${createdSla.id} for incident ${data.incidentId} with rule ${matchingRule.name || matchingRule.id}`,
+      );
+
+      return createdSla;
+    } catch (error) {
+      logger.error(
+        `Error creating SLA record for incident ${data.incidentId}: ${error}`,
+      );
+      return null;
+    }
+  }
+
+  @CaptureSpan()
+  public async markResponded(data: {
+    incidentId: ObjectID;
+    respondedAt: Date;
+  }): Promise<void> {
+    logger.debug(
+      `Marking incident ${data.incidentId} as responded at ${data.respondedAt}`,
+    );
+
+    // Find all active SLA records for this incident
+    const slaRecords: Array<Model> = await this.findBy({
+      query: {
+        incidentId: data.incidentId,
+        resolvedAt: QueryHelper.isNull(),
+      },
+      select: {
+        _id: true,
+        respondedAt: true,
+        status: true,
+        responseDeadline: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const sla of slaRecords) {
+      // Only update if not already responded
+      if (!sla.respondedAt && sla.id) {
+        await this.updateOneById({
+          id: sla.id,
+          data: {
+            respondedAt: data.respondedAt,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.info(`Marked SLA ${sla.id} as responded at ${data.respondedAt}`);
+      }
+    }
+  }
+
+  @CaptureSpan()
+  public async markResolved(data: {
+    incidentId: ObjectID;
+    resolvedAt: Date;
+  }): Promise<void> {
+    logger.debug(
+      `Marking incident ${data.incidentId} as resolved at ${data.resolvedAt}`,
+    );
+
+    // Find all active SLA records for this incident
+    const slaRecords: Array<Model> = await this.findBy({
+      query: {
+        incidentId: data.incidentId,
+        resolvedAt: QueryHelper.isNull(),
+      },
+      select: {
+        _id: true,
+        status: true,
+        resolutionDeadline: true,
+        responseDeadline: true,
+        respondedAt: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const sla of slaRecords) {
+      if (!sla.id) {
+        continue;
+      }
+
+      // Determine final SLA status
+      let finalStatus: IncidentSlaStatus = IncidentSlaStatus.Met;
+
+      // Check if response deadline was breached
+      if (sla.responseDeadline && !sla.respondedAt) {
+        // Never responded, check if response deadline passed
+        if (OneUptimeDate.isAfter(data.resolvedAt, sla.responseDeadline)) {
+          finalStatus = IncidentSlaStatus.ResponseBreached;
+        }
+      } else if (
+        sla.responseDeadline &&
+        sla.respondedAt &&
+        OneUptimeDate.isAfter(sla.respondedAt, sla.responseDeadline)
+      ) {
+        // Responded after deadline
+        finalStatus = IncidentSlaStatus.ResponseBreached;
+      }
+
+      // Check if resolution deadline was breached (takes precedence)
+      if (
+        sla.resolutionDeadline &&
+        OneUptimeDate.isAfter(data.resolvedAt, sla.resolutionDeadline)
+      ) {
+        finalStatus = IncidentSlaStatus.ResolutionBreached;
+      }
+
+      await this.updateOneById({
+        id: sla.id,
+        data: {
+          resolvedAt: data.resolvedAt,
+          status: finalStatus,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      logger.info(
+        `Marked SLA ${sla.id} as resolved with status ${finalStatus}`,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  public async recalculateDeadlines(data: {
+    incidentId: ObjectID;
+  }): Promise<void> {
+    logger.debug(`Recalculating deadlines for incident ${data.incidentId}`);
+
+    // Get the incident to find the new severity and project
+    const incident: Incident | null = await IncidentService.findOneById({
+      id: data.incidentId,
+      select: {
+        projectId: true,
+        declaredAt: true,
+        incidentSeverityId: true,
+        title: true,
+        description: true,
+        monitors: {
+          _id: true,
+          labels: {
+            _id: true,
+          },
+        },
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident || !incident.projectId) {
+      logger.warn(`Incident ${data.incidentId} not found`);
+      return;
+    }
+
+    // Find all active SLA records for this incident
+    const slaRecords: Array<Model> = await this.findBy({
+      query: {
+        incidentId: data.incidentId,
+        resolvedAt: QueryHelper.isNull(),
+      },
+      select: {
+        _id: true,
+        slaStartedAt: true,
+        incidentSlaRuleId: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Find new matching rule (may be different due to severity change)
+    const newMatchingRule: IncidentSlaRule | null =
+      await IncidentSlaRuleService.findMatchingRule({
+        incidentId: data.incidentId,
+        projectId: incident.projectId,
+        incident: incident,
+      });
+
+    for (const sla of slaRecords) {
+      if (!sla.id || !sla.slaStartedAt) {
+        continue;
+      }
+
+      // Check if the matching rule has changed
+      if (
+        newMatchingRule &&
+        newMatchingRule.id?.toString() !== sla.incidentSlaRuleId?.toString()
+      ) {
+        // Rule has changed, recalculate with new rule
+        let responseDeadline: Date | undefined = undefined;
+        let resolutionDeadline: Date | undefined = undefined;
+
+        if (newMatchingRule.responseTimeInMinutes) {
+          responseDeadline = OneUptimeDate.addRemoveMinutes(
+            sla.slaStartedAt,
+            newMatchingRule.responseTimeInMinutes,
+          );
+        }
+
+        if (newMatchingRule.resolutionTimeInMinutes) {
+          resolutionDeadline = OneUptimeDate.addRemoveMinutes(
+            sla.slaStartedAt,
+            newMatchingRule.resolutionTimeInMinutes,
+          );
+        }
+
+        await this.updateOneById({
+          id: sla.id,
+          data: {
+            incidentSlaRuleId: newMatchingRule.id,
+            responseDeadline: responseDeadline || null,
+            resolutionDeadline: resolutionDeadline || null,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.info(
+          `Recalculated SLA ${sla.id} with new rule ${newMatchingRule.name || newMatchingRule.id}`,
+        );
+      } else if (!newMatchingRule) {
+        // No matching rule anymore, but keep the existing SLA record
+        logger.debug(
+          `No matching SLA rule found after severity change for incident ${data.incidentId}, keeping existing SLA`,
+        );
+      }
+    }
+  }
+
+  @CaptureSpan()
+  public async getIncidentsNeedingInternalNoteReminder(): Promise<
+    Array<Model>
+  > {
+    /*
+     * Find SLAs where:
+     * - Not resolved
+     * - Has internal note reminder interval configured
+     * - Last reminder was sent more than interval ago OR never sent
+     */
+    const now: Date = OneUptimeDate.getCurrentDate();
+
+    const slaRecords: Array<Model> = await this.findBy({
+      query: {
+        resolvedAt: QueryHelper.isNull(),
+      },
+      select: {
+        _id: true,
+        incidentId: true,
+        projectId: true,
+        incidentSlaRuleId: true,
+        incidentSlaRule: {
+          internalNoteReminderIntervalInMinutes: true,
+          internalNoteReminderTemplate: true,
+        },
+        slaStartedAt: true,
+        responseDeadline: true,
+        resolutionDeadline: true,
+        status: true,
+        lastInternalNoteReminderSentAt: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Filter to only those needing reminders
+    const needingReminder: Array<Model> = slaRecords.filter((sla: Model) => {
+      const interval: number | undefined =
+        sla.incidentSlaRule?.internalNoteReminderIntervalInMinutes;
+
+      if (!interval) {
+        return false;
+      }
+
+      if (!sla.lastInternalNoteReminderSentAt) {
+        // Never sent, check if enough time has passed since SLA started
+        const timeSinceStart: number = OneUptimeDate.getDifferenceInMinutes(
+          now,
+          sla.slaStartedAt!,
+        );
+        return timeSinceStart >= interval;
+      }
+
+      const timeSinceLastReminder: number =
+        OneUptimeDate.getDifferenceInMinutes(
+          now,
+          sla.lastInternalNoteReminderSentAt,
+        );
+
+      return timeSinceLastReminder >= interval;
+    });
+
+    return needingReminder;
+  }
+
+  @CaptureSpan()
+  public async getIncidentsNeedingPublicNoteReminder(): Promise<Array<Model>> {
+    const now: Date = OneUptimeDate.getCurrentDate();
+
+    const slaRecords: Array<Model> = await this.findBy({
+      query: {
+        resolvedAt: QueryHelper.isNull(),
+      },
+      select: {
+        _id: true,
+        incidentId: true,
+        projectId: true,
+        incidentSlaRuleId: true,
+        incidentSlaRule: {
+          publicNoteReminderIntervalInMinutes: true,
+          publicNoteReminderTemplate: true,
+        },
+        slaStartedAt: true,
+        responseDeadline: true,
+        resolutionDeadline: true,
+        status: true,
+        lastPublicNoteReminderSentAt: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Filter to only those needing reminders
+    const needingReminder: Array<Model> = slaRecords.filter((sla: Model) => {
+      const interval: number | undefined =
+        sla.incidentSlaRule?.publicNoteReminderIntervalInMinutes;
+
+      if (!interval) {
+        return false;
+      }
+
+      if (!sla.lastPublicNoteReminderSentAt) {
+        // Never sent, check if enough time has passed since SLA started
+        const timeSinceStart: number = OneUptimeDate.getDifferenceInMinutes(
+          now,
+          sla.slaStartedAt!,
+        );
+        return timeSinceStart >= interval;
+      }
+
+      const timeSinceLastReminder: number =
+        OneUptimeDate.getDifferenceInMinutes(
+          now,
+          sla.lastPublicNoteReminderSentAt,
+        );
+
+      return timeSinceLastReminder >= interval;
+    });
+
+    return needingReminder;
+  }
+
+  @CaptureSpan()
+  public async getSlasNeedingBreachCheck(): Promise<Array<Model>> {
+    // Find SLAs where status is OnTrack or AtRisk and not resolved
+    return await this.findBy({
+      query: {
+        resolvedAt: QueryHelper.isNull(),
+        status: QueryHelper.any([
+          IncidentSlaStatus.OnTrack,
+          IncidentSlaStatus.AtRisk,
+        ]),
+      },
+      select: {
+        _id: true,
+        incidentId: true,
+        projectId: true,
+        incidentSlaRuleId: true,
+        incidentSlaRule: {
+          atRiskThresholdInPercentage: true,
+          name: true,
+        },
+        slaStartedAt: true,
+        responseDeadline: true,
+        resolutionDeadline: true,
+        respondedAt: true,
+        status: true,
+        breachNotificationSentAt: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async getActiveSlasForIncident(data: {
+    incidentId: ObjectID;
+  }): Promise<Array<Model>> {
+    return await this.findBy({
+      query: {
+        incidentId: data.incidentId,
+        resolvedAt: QueryHelper.isNull(),
+      },
+      select: {
+        _id: true,
+        incidentId: true,
+        projectId: true,
+        incidentSlaRuleId: true,
+        incidentSlaRule: {
+          name: true,
+          responseTimeInMinutes: true,
+          resolutionTimeInMinutes: true,
+          atRiskThresholdInPercentage: true,
+        },
+        slaStartedAt: true,
+        responseDeadline: true,
+        resolutionDeadline: true,
+        respondedAt: true,
+        resolvedAt: true,
+        status: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+}
+
+export default new Service();