@oneuptime/common 11.3.20 → 11.3.22

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

@@ -113,6 +113,7 @@ import GlobalSsoProjectService from "./GlobalSsoProjectService";
 import GlobalOidcProjectService from "./GlobalOidcProjectService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
+import EnterpriseLicenseInstanceService from "./EnterpriseLicenseInstanceService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
 import ResellerPlanService from "./ResellerPlanService";
 import ResellerService from "./ResellerService";
@@ -225,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";
@@ -251,6 +255,7 @@ const services: Array<BaseService> = [
   AcmeCertificateService,
   PromoCodeService,
   EnterpriseLicenseService,
+  EnterpriseLicenseInstanceService,
   OpenSourceDeploymentService,
 
   ResellerService,
@@ -479,6 +484,9 @@ const services: Array<BaseService> = [
   AlertGroupingRuleService,
   IncidentSlaRuleService,
   IncidentSlaService,
+  IncidentReminderRuleService,
+  AlertReminderRuleService,
+  ScheduledMaintenanceReminderRuleService,
 
   TableViewService,
   MonitorTestService,

package/Server/Services/IoTDeviceService.ts

@@ -1,8 +1,10 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/IoTDevice";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ColumnLength from "../../Types/Database/ColumnLength";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
+import { clampIoTTimestamp } from "../Utils/Telemetry/IoTSnapshotScan";
 import logger from "../Utils/Logger";
 
 /*
@@ -57,6 +59,23 @@ export interface IoTInventorySummary {
 const UPSERT_BATCH_SIZE: number = 500;
 const STALE_DELETE_WARN_THRESHOLD: number = 100;
 
+/*
+ * The identity/text columns are ShortText (100 chars). A single value
+ * over the column limit fails the whole multi-row INSERT chunk it rides
+ * in — truncate per value instead so one malformed device can never
+ * drop the other rows of its chunk.
+ */
+function truncateShortText(value: string): string;
+function truncateShortText(value: string | null): string | null;
+function truncateShortText(value: string | null): string | null {
+  if (value === null) {
+    return value;
+  }
+  return value.length > ColumnLength.ShortText
+    ? value.substring(0, ColumnLength.ShortText)
+    : value;
+}
+
 /*
  * Column order used by bulkUpsert() and its generated parameter tuples.
  * Keep this and the INSERT column list in perfect sync.
@@ -103,9 +122,52 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
+    /*
+     * Sanitize before building chunks: ShortText columns truncate to
+     * the column limit (one over-long device.id must not fail the
+     * whole 500-row chunk), lastSeenAt clamps so a future-skewed
+     * device clock can't wedge the `>=` dominance guard, and rows that
+     * collide on the conflict target after truncation dedupe to the
+     * newest observation (two VALUES rows hitting the same conflict
+     * target would abort the statement).
+     */
+    const dedupedByIdentity: Map<string, ParsedIoTDevice> = new Map();
+    for (const r of data.devices) {
+      const externalId: string = truncateShortText(r.externalId);
+      if (!externalId) {
+        continue;
+      }
+      if (externalId !== r.externalId) {
+        logger.warn(
+          `IoTDevice externalId exceeds ${ColumnLength.ShortText} chars; truncated to "${externalId}" (fleet ${data.iotFleetId.toString()}).`,
+        );
+      }
+      const device: ParsedIoTDevice = {
+        ...r,
+        kind: truncateShortText(r.kind),
+        externalId,
+        name: truncateShortText(r.name),
+        deviceType: truncateShortText(r.deviceType),
+        firmwareVersion: truncateShortText(r.firmwareVersion),
+        lastSeenAt: clampIoTTimestamp(r.lastSeenAt),
+      };
+      const key: string = `${device.kind}|${device.externalId}`;
+      const existing: ParsedIoTDevice | undefined = dedupedByIdentity.get(key);
+      if (!existing || device.lastSeenAt >= existing.lastSeenAt) {
+        dedupedByIdentity.set(key, device);
+      }
+    }
+
+    const devices: Array<ParsedIoTDevice> = Array.from(
+      dedupedByIdentity.values(),
+    );
+    if (devices.length === 0) {
+      return;
+    }
+
     // Chunk to keep individual statement parameter counts reasonable.
-    for (let i: number = 0; i < data.devices.length; i += UPSERT_BATCH_SIZE) {
-      const chunk: Array<ParsedIoTDevice> = data.devices.slice(
+    for (let i: number = 0; i < devices.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<ParsedIoTDevice> = devices.slice(
         i,
         i + UPSERT_BATCH_SIZE,
       );
@@ -181,8 +243,41 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
-    for (let i: number = 0; i < data.metrics.length; i += UPSERT_BATCH_SIZE) {
-      const chunk: Array<IoTDeviceLatestMetric> = data.metrics.slice(
+    /*
+     * Same sanitation as bulkUpsert — and the identity truncation MUST
+     * match it, or the mirror UPDATE would silently miss the row the
+     * upsert just wrote under the truncated id. Dedupe keeps the UPDATE
+     * deterministic when two rows collapse onto one identity.
+     */
+    const dedupedByIdentity: Map<string, IoTDeviceLatestMetric> = new Map();
+    for (const m of data.metrics) {
+      const externalId: string = truncateShortText(m.externalId);
+      if (!externalId) {
+        continue;
+      }
+      const metric: IoTDeviceLatestMetric = {
+        ...m,
+        kind: truncateShortText(m.kind),
+        externalId,
+        observedAt: clampIoTTimestamp(m.observedAt),
+      };
+      const key: string = `${metric.kind}|${metric.externalId}`;
+      const existing: IoTDeviceLatestMetric | undefined =
+        dedupedByIdentity.get(key);
+      if (!existing || metric.observedAt >= existing.observedAt) {
+        dedupedByIdentity.set(key, metric);
+      }
+    }
+
+    const metrics: Array<IoTDeviceLatestMetric> = Array.from(
+      dedupedByIdentity.values(),
+    );
+    if (metrics.length === 0) {
+      return;
+    }
+
+    for (let i: number = 0; i < metrics.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<IoTDeviceLatestMetric> = metrics.slice(
         i,
         i + UPSERT_BATCH_SIZE,
       );

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();