@oneuptime/common 11.1.2 → 11.2.1

package/Server/Services/StatusPageService.ts

@@ -45,6 +45,10 @@ import StatusPageSubscriberService from "./StatusPageSubscriberService";
 import StatusPageSubscriber from "../../Models/DatabaseModels/StatusPageSubscriber";
 import MailService from "./MailService";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import StatusPageSubscriberNotificationTemplateService from "./StatusPageSubscriberNotificationTemplateService";
+import StatusPageSubscriberNotificationTemplate from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
+import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
+import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
 import { StatusPageApiRoute } from "../../ServiceRoute";
 import ProjectSMTPConfigService from "./ProjectSmtpConfigService";
 import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
@@ -867,6 +871,25 @@ export class Service extends DatabaseService<StatusPage> {
       historyDays: statuspage.reportDataInDays || 14,
     });
 
+    /*
+     * Look up a custom report email template for this status page (if any).
+     * When present (and a custom SMTP is configured, mirroring the gating used
+     * for other subscriber notifications), the subscriber receives the custom
+     * template instead of the built-in StatusPageSubscriberReport.hbs. The
+     * custom body is rendered through Handlebars on the notification side
+     * (templateType omitted => MailService compiles the body string with the
+     * same `report` vars, helpers and partials), so it supports loops/
+     * conditionals such as {{#each report.resources}}.
+     */
+    const customReportEmailTemplate: StatusPageSubscriberNotificationTemplate | null =
+      await StatusPageSubscriberNotificationTemplateService.getTemplateForStatusPage(
+        {
+          statusPageId: statuspage.id!,
+          eventType: StatusPageSubscriberNotificationEventType.SubscriberReport,
+          notificationMethod: StatusPageSubscriberNotificationMethod.Email,
+        },
+      );
+
     type SendEmailFunction = (
       email: Email,
       unsubscribeUrl: URL | null,
@@ -878,33 +901,53 @@ export class Service extends DatabaseService<StatusPage> {
     ): Promise<void> => {
       // send email here.
 
+      const vars: Dictionary<string | JSONObject> = {
+        statusPageName: statusPageName,
+        subscriberEmailNotificationFooterText:
+          Service.getSubscriberEmailFooterText(statuspage),
+        statusPageUrl: statusPageURL,
+        detailsUrl: statusPageURL,
+        hasResources: report.totalResources > 0 ? "true" : "false",
+        report: report as any,
+        logoUrl:
+          statuspage.logoFileId && statusPageIdString
+            ? new URL(httpProtocol, host)
+                .addRoute(StatusPageApiRoute)
+                .addRoute(`/logo/${statusPageIdString}`)
+                .toString()
+            : "",
+        isPublicStatusPage: statuspage.isPublicStatusPage ? "true" : "false",
+
+        unsubscribeUrl: unsubscribeUrl?.toString() || "",
+      };
+
+      /*
+       * Use the custom template only when a custom SMTP is configured for the
+       * status page, matching the gating used by the other subscriber
+       * notifications (e.g. Incident). Custom-authored HTML is then sent from
+       * the customer's own mail server rather than the shared servers.
+       */
+      const useCustomTemplate: boolean = Boolean(
+        customReportEmailTemplate?.templateBody && statuspage.smtpConfig,
+      );
+
       MailService.sendMail(
-        {
-          toEmail: email,
-          templateType: EmailTemplateType.StatusPageSubscriberReport,
-          vars: {
-            statusPageName: statusPageName,
-            subscriberEmailNotificationFooterText:
-              Service.getSubscriberEmailFooterText(statuspage),
-            statusPageUrl: statusPageURL,
-            detailsUrl: statusPageURL,
-            hasResources: report.totalResources > 0 ? "true" : "false",
-            report: report as any,
-            logoUrl:
-              statuspage.logoFileId && statusPageIdString
-                ? new URL(httpProtocol, host)
-                    .addRoute(StatusPageApiRoute)
-                    .addRoute(`/logo/${statusPageIdString}`)
-                    .toString()
-                : "",
-            isPublicStatusPage: statuspage.isPublicStatusPage
-              ? "true"
-              : "false",
-
-            unsubscribeUrl: unsubscribeUrl?.toString() || "",
-          },
-          subject: "[Report] " + statusPageName,
-        },
+        useCustomTemplate
+          ? {
+              toEmail: email,
+              // templateType omitted => body is compiled as a Handlebars string.
+              body: customReportEmailTemplate!.templateBody!,
+              vars: vars,
+              subject: customReportEmailTemplate!.emailSubject
+                ? customReportEmailTemplate!.emailSubject
+                : "[Report] " + statusPageName,
+            }
+          : {
+              toEmail: email,
+              templateType: EmailTemplateType.StatusPageSubscriberReport,
+              vars: vars,
+              subject: "[Report] " + statusPageName,
+            },
         {
           mailServer: ProjectSMTPConfigService.toEmailServer(
             statuspage.smtpConfig,

package/Server/Services/StatusPageSubscriberNotificationTemplateService.ts

@@ -245,6 +245,42 @@ export class Service extends DatabaseService<Model> {
           },
         ];
 
+      case StatusPageSubscriberNotificationEventType.SubscriberReport:
+        /*
+         * The report template is rendered through the full Handlebars engine
+         * with the structured `report` object, so the per-resource fields are
+         * accessed inside {{#each report.resources}} rather than as flat
+         * scalars. The entries below document the top-level paths.
+         */
+        return [
+          ...commonVariables,
+          {
+            name: "report.reportDates",
+            description: "The reporting period",
+          },
+          {
+            name: "report.averageUptimePercent",
+            description: "Average uptime across all resources",
+          },
+          {
+            name: "report.totalDowntimeInHoursAndMinutes",
+            description: "Total downtime in the period",
+          },
+          {
+            name: "report.totalIncidents",
+            description: "Total number of incidents in the period",
+          },
+          {
+            name: "report.totalResources",
+            description: "Number of resources on the status page",
+          },
+          {
+            name: "report.resources",
+            description:
+              "Array of per-resource rows (resourceName, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount) to loop over with {{#each}}",
+          },
+        ];
+
       default:
         throw new BadDataException(`Unknown event type: ${eventType}`);
     }

package/Server/Services/TelemetryUsageBillingService.ts

@@ -29,11 +29,13 @@ import PodmanHostService from "./PodmanHostService";
 import KubernetesClusterService from "./KubernetesClusterService";
 import ProxmoxClusterService from "./ProxmoxClusterService";
 import CephClusterService from "./CephClusterService";
+import IoTFleetService from "./IoTFleetService";
 import Host from "../../Models/DatabaseModels/Host";
 import DockerHost from "../../Models/DatabaseModels/DockerHost";
 import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
 import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
 import ProxmoxCluster from "../../Models/DatabaseModels/ProxmoxCluster";
+import IoTFleet from "../../Models/DatabaseModels/IoTFleet";
 import CephCluster from "../../Models/DatabaseModels/CephCluster";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 import {
@@ -478,6 +480,22 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    const iotFleets: Array<IoTFleet> = await IoTFleetService.findBy({
+      query: { projectId: projectId },
+      select: { _id: true, retainTelemetryDataForDays: true },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: { isRoot: true },
+    });
+    for (const iotFleet of iotFleets) {
+      if (iotFleet.id && iotFleet.retainTelemetryDataForDays) {
+        retentionByServiceId.set(
+          iotFleet.id.toString(),
+          iotFleet.retainTelemetryDataForDays,
+        );
+      }
+    }
+
     return retentionByServiceId;
   }
 

package/Server/Services/TraceAggregationService.ts

@@ -568,6 +568,180 @@ export class TraceAggregationService {
     return { serviceCounts, statusCounts };
   }
 
+  /*
+   * Exact root-span vs non-root-span counts over the full window, backing the
+   * "Span Type" sidebar facet. Like getResourceFacetCounts this rides the
+   * proj_hist_by_minute aggregate projection (isRootSpan is a projection key),
+   * so it reads a few pre-aggregated minute rows in single-digit ms rather than
+   * scanning raw spans — same toStartOfMinute()/optimize_use_projections
+   * requirements apply.
+   *
+   * rootOnly is deliberately forced OFF here: a facet must not filter by its
+   * own dimension, or the unselected bucket would always read 0 and the user
+   * could never see how many root vs non-root spans exist (the exact confusion
+   * the facet is meant to resolve). Every OTHER active filter (service /
+   * status / ...) still applies, so the counts narrow with the rest of the
+   * sidebar.
+   */
+  @CaptureSpan()
+  public static async getRootSpanCounts(request: MultiFacetRequest): Promise<{
+    rootCount: number;
+    nonRootCount: number;
+  }> {
+    const statement: Statement = new Statement();
+    statement.append(
+      `SELECT isRootSpan, count() AS cnt FROM ${TraceAggregationService.TABLE_NAME}`,
+    );
+    statement.append(
+      SQL` WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }} AND toStartOfMinute(startTime) >= toStartOfMinute(${{
+        type: TableColumnType.Date,
+        value: request.startTime,
+      }}) AND toStartOfMinute(startTime) <= toStartOfMinute(${{
+        type: TableColumnType.Date,
+        value: request.endTime,
+      }})`,
+    );
+
+    // Force rootOnly off so both buckets survive (see method comment).
+    TraceAggregationService.appendCommonFilters(statement, {
+      ...request,
+      rootOnly: false,
+    });
+
+    statement.append(" GROUP BY isRootSpan");
+
+    statement.append(
+      getQuerySettings({
+        maxExecutionTimeInSeconds: 45,
+        timeoutOverflowMode: "break",
+        additionalSettings: { optimize_use_projections: 1 },
+      }),
+    );
+
+    let rootCount: number = 0;
+    let nonRootCount: number = 0;
+
+    const dbResult: Results = await SpanService.executeQuery(statement);
+
+    let rows: Array<JSONObject> = [];
+    try {
+      const response: DbJSONResponse = await dbResult.json<{
+        data?: Array<JSONObject>;
+      }>();
+      rows = response.data || [];
+    } catch {
+      // 'break' mode can truncate JSON on timeout — degrade to zero counts.
+      logger.warn(
+        "Root span count query returned unparseable response, returning zero counts",
+      );
+      return { rootCount, nonRootCount };
+    }
+
+    for (const row of rows) {
+      const cnt: number = Number(row["cnt"] || 0);
+      const raw: unknown = row["isRootSpan"];
+      // ClickHouse Bool may serialize as true/false, 1/0, or "1"/"true".
+      const isRoot: boolean =
+        raw === true || raw === 1 || raw === "1" || raw === "true";
+      if (isRoot) {
+        rootCount += cnt;
+      } else {
+        nonRootCount += cnt;
+      }
+    }
+
+    return { rootCount, nonRootCount };
+  }
+
+  /*
+   * Exact has-exception vs no-exception counts over the window, backing the
+   * "Has Exception" sidebar facet. Unlike getResourceFacetCounts /
+   * getRootSpanCounts, hasException is not a proj_hist_by_minute key, so this
+   * is a base-table GROUP BY (still bounded by max_execution_time / 'break').
+   * It is a single low-cardinality column read, so it is cheap for typical
+   * windows and degrades gracefully on very wide ones.
+   *
+   * Exactness matters specifically here: exception spans are usually rare, so
+   * the recent-N sample (getFacetValuesFromSample) can miss them entirely and
+   * report 0 — actively misleading for the one facet whose purpose is to find
+   * exceptions. Every active filter (incl. rootOnly) still applies via
+   * appendCommonFilters, so the count narrows with the rest of the sidebar.
+   */
+  @CaptureSpan()
+  public static async getHasExceptionCounts(
+    request: MultiFacetRequest,
+  ): Promise<{
+    withExceptionCount: number;
+    withoutExceptionCount: number;
+  }> {
+    const statement: Statement = new Statement();
+    statement.append(
+      `SELECT hasException, count() AS cnt FROM ${TraceAggregationService.TABLE_NAME}`,
+    );
+    statement.append(
+      SQL` WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }} AND startTime >= ${{
+        type: TableColumnType.Date,
+        value: request.startTime,
+      }} AND startTime <= ${{
+        type: TableColumnType.Date,
+        value: request.endTime,
+      }}`,
+    );
+
+    statement.append(TraceAggregationService.RETENTION_FILTER);
+
+    TraceAggregationService.appendCommonFilters(statement, request);
+
+    statement.append(" GROUP BY hasException");
+
+    statement.append(
+      getQuerySettings({
+        maxExecutionTimeInSeconds: 45,
+        timeoutOverflowMode: "break",
+      }),
+    );
+
+    let withExceptionCount: number = 0;
+    let withoutExceptionCount: number = 0;
+
+    const dbResult: Results = await SpanService.executeQuery(statement);
+
+    let rows: Array<JSONObject> = [];
+    try {
+      const response: DbJSONResponse = await dbResult.json<{
+        data?: Array<JSONObject>;
+      }>();
+      rows = response.data || [];
+    } catch {
+      // 'break' mode can truncate JSON on timeout — degrade to zero counts.
+      logger.warn(
+        "Has-exception count query returned unparseable response, returning zero counts",
+      );
+      return { withExceptionCount, withoutExceptionCount };
+    }
+
+    for (const row of rows) {
+      const cnt: number = Number(row["cnt"] || 0);
+      const raw: unknown = row["hasException"];
+      // ClickHouse Bool may serialize as true/false, 1/0, or "1"/"true".
+      const hasException: boolean =
+        raw === true || raw === 1 || raw === "1" || raw === "true";
+      if (hasException) {
+        withExceptionCount += cnt;
+      } else {
+        withoutExceptionCount += cnt;
+      }
+    }
+
+    return { withExceptionCount, withoutExceptionCount };
+  }
+
   private static mapStatusCodeToSeries(code: number): string {
     if (code === 1) {
       return "ok";

package/Server/Utils/Monitor/Criteria/ServerMonitorCriteria.ts

@@ -192,7 +192,7 @@ export default class ServerMonitorCriteria {
 
       const diskMetric: BasicDiskMetrics | undefined = (
         input.dataToProcess as ServerMonitorResponse
-      ).basicInfrastructureMetrics?.diskMetrics.find(
+      ).basicInfrastructureMetrics?.diskMetrics?.find(
         (item: BasicDiskMetrics) => {
           return normalizeDiskPath(item.diskPath) === normalizedDiskPath;
         },

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -8,6 +8,7 @@ import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
 import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import IoTFleet from "../../../Models/DatabaseModels/IoTFleet";
 import Service from "../../../Models/DatabaseModels/Service";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
@@ -217,11 +218,19 @@ export default class MonitorAlert {
           continue;
         }
 
+        /*
+         * Mirror the create path: `createdCriteriaId` is only set when the
+         * criteria has an `id`. Guard the `.toString()` with `?.` (a criteria
+         * with a missing id otherwise threw "Cannot read properties of
+         * undefined (reading 'toString')" and failed the queue job every
+         * cycle) and normalise both sides to `undefined` on missing so dedupe
+         * stays correct instead of creating a duplicate alert each cycle.
+         */
         const alreadyOpenAlert: Alert | undefined = openAlerts.find(
           (alert: Alert) => {
             return (
-              alert.createdCriteriaId ===
-                input.criteriaInstance.data?.id.toString() &&
+              (alert.createdCriteriaId || undefined) ===
+                (input.criteriaInstance.data?.id?.toString() || undefined) &&
               (alert.seriesFingerprint || undefined) === seriesFingerprint
             );
           },
@@ -318,7 +327,9 @@ export default class MonitorAlert {
           JSON.stringify(input.dataToProcess, null, 2),
         );
 
-        alert.createdCriteriaId = input.criteriaInstance.data.id.toString();
+        if (input.criteriaInstance.data?.id) {
+          alert.createdCriteriaId = input.criteriaInstance.data.id.toString();
+        }
 
         if (seriesFingerprint) {
           alert.seriesFingerprint = seriesFingerprint;
@@ -430,6 +441,15 @@ export default class MonitorAlert {
             },
           );
         }
+        if (clusterContext.iotFleetIds.length > 0) {
+          alert.iotFleets = clusterContext.iotFleetIds.map(
+            (id: string): IoTFleet => {
+              const fleet: IoTFleet = new IoTFleet();
+              fleet._id = id;
+              return fleet;
+            },
+          );
+        }
 
         alert.onCallDutyPolicies =
           criteriaAlert.onCallPolicyIds?.map((id: ObjectID) => {
@@ -610,7 +630,7 @@ export default class MonitorAlert {
 
     if (
       input.openAlert.createdCriteriaId?.toString() ===
-      input.criteriaInstance?.data?.id.toString()
+      input.criteriaInstance?.data?.id?.toString()
     ) {
       // same alert active. So, do not close.
       return false;

package/Server/Utils/Monitor/MonitorClusterContext.ts

@@ -1,11 +1,13 @@
 import CephCluster from "../../../Models/DatabaseModels/CephCluster";
 import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
+import IoTFleet from "../../../Models/DatabaseModels/IoTFleet";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import MonitorType from "../../../Types/Monitor/MonitorType";
 import CephClusterService from "../../Services/CephClusterService";
 import DockerSwarmClusterService from "../../Services/DockerSwarmClusterService";
+import IoTFleetService from "../../Services/IoTFleetService";
 import ProxmoxClusterService from "../../Services/ProxmoxClusterService";
 import QueryHelper from "../../Types/Database/QueryHelper";
 import logger from "../Logger";
@@ -26,6 +28,7 @@ export interface MonitorClusterContext {
   proxmoxClusterIds: Array<string>;
   cephClusterIds: Array<string>;
   dockerSwarmClusterIds: Array<string>;
+  iotFleetIds: Array<string>;
 }
 
 export default class MonitorClusterContextUtil {
@@ -46,6 +49,7 @@ export default class MonitorClusterContextUtil {
       proxmoxClusterIds: [],
       cephClusterIds: [],
       dockerSwarmClusterIds: [],
+      iotFleetIds: [],
     };
 
     const monitorType: MonitorType | undefined = input.monitor.monitorType;
@@ -53,7 +57,8 @@ export default class MonitorClusterContextUtil {
     if (
       monitorType !== MonitorType.Proxmox &&
       monitorType !== MonitorType.Ceph &&
-      monitorType !== MonitorType.DockerSwarm
+      monitorType !== MonitorType.DockerSwarm &&
+      monitorType !== MonitorType.IoTDevice
     ) {
       return context;
     }
@@ -77,6 +82,8 @@ export default class MonitorClusterContextUtil {
       } else if (monitorType === MonitorType.DockerSwarm) {
         clusterIdentifier =
           monitorStep.data?.dockerSwarmMonitor?.clusterIdentifier;
+      } else if (monitorType === MonitorType.IoTDevice) {
+        clusterIdentifier = monitorStep.data?.iotMonitor?.fleetIdentifier;
       }
 
       if (clusterIdentifier && clusterIdentifier.trim().length > 0) {
@@ -127,7 +134,7 @@ export default class MonitorClusterContextUtil {
           if (cephCluster?._id) {
             context.cephClusterIds.push(String(cephCluster._id));
           }
-        } else {
+        } else if (monitorType === MonitorType.DockerSwarm) {
           const dockerSwarmCluster: DockerSwarmCluster | null =
             await DockerSwarmClusterService.findOneBy({
               query: {
@@ -145,6 +152,23 @@ export default class MonitorClusterContextUtil {
           if (dockerSwarmCluster?._id) {
             context.dockerSwarmClusterIds.push(String(dockerSwarmCluster._id));
           }
+        } else {
+          const iotFleet: IoTFleet | null = await IoTFleetService.findOneBy({
+            query: {
+              projectId: input.monitor.projectId,
+              name: QueryHelper.findWithSameText(clusterIdentifier),
+            },
+            select: {
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          if (iotFleet?._id) {
+            context.iotFleetIds.push(String(iotFleet._id));
+          }
         }
       } catch (err) {
         logger.error(

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -246,7 +246,8 @@ ${contextBlock}
       input.monitor.monitorType !== MonitorType.Podman &&
       input.monitor.monitorType !== MonitorType.DockerSwarm &&
       input.monitor.monitorType !== MonitorType.Proxmox &&
-      input.monitor.monitorType !== MonitorType.Ceph
+      input.monitor.monitorType !== MonitorType.Ceph &&
+      input.monitor.monitorType !== MonitorType.IoTDevice
     ) {
       return [];
     }
@@ -697,7 +698,8 @@ ${contextBlock}
       input.monitor.monitorType === MonitorType.Podman ||
       input.monitor.monitorType === MonitorType.DockerSwarm ||
       input.monitor.monitorType === MonitorType.Proxmox ||
-      input.monitor.monitorType === MonitorType.Ceph
+      input.monitor.monitorType === MonitorType.Ceph ||
+      input.monitor.monitorType === MonitorType.IoTDevice
     ) {
       const metricMonitorResult: string | null =
         await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -12,6 +12,7 @@ import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
 import PodmanHost from "../../../Models/DatabaseModels/PodmanHost";
 import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import IoTFleet from "../../../Models/DatabaseModels/IoTFleet";
 import Service from "../../../Models/DatabaseModels/Service";
 import Includes from "../../../Types/BaseDatabase/Includes";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -267,13 +268,25 @@ export default class MonitorIncident {
           continue;
         }
 
+        /*
+         * Dedupe match must mirror the create path below (which sets
+         * `createdCriteriaId` / `createdIncidentTemplateId` only when the
+         * corresponding id is present). A criteria incident template can be
+         * missing its `id` (legacy/API-authored criteria), so guard the
+         * `.toString()` with `?.` — an unguarded call previously threw
+         * "Cannot read properties of undefined (reading 'toString')" here and
+         * failed the probe/telemetry queue job on every cycle for the affected
+         * monitor. Normalise both sides to `undefined` on missing so a created
+         * incident (whose template id was left NULL) still matches itself next
+         * cycle instead of being recreated as a duplicate.
+         */
         const alreadyOpenIncident: Incident | undefined = openIncidents.find(
           (incident: Incident) => {
             return (
-              incident.createdCriteriaId ===
-                input.criteriaInstance.data?.id.toString() &&
-              incident.createdIncidentTemplateId ===
-                criteriaIncident.id.toString() &&
+              (incident.createdCriteriaId || undefined) ===
+                (input.criteriaInstance.data?.id?.toString() || undefined) &&
+              (incident.createdIncidentTemplateId || undefined) ===
+                (criteriaIncident.id?.toString() || undefined) &&
               (incident.seriesFingerprint || undefined) === seriesFingerprint
             );
           },
@@ -808,6 +821,27 @@ export default class MonitorIncident {
 
       input.incident.dockerSwarmClusters = merged;
     }
+
+    if (input.clusterContext.iotFleetIds.length > 0) {
+      const existingIds: Set<string> = new Set<string>(
+        (input.incident.iotFleets || []).map((fleet: IoTFleet) => {
+          return String(fleet._id);
+        }),
+      );
+
+      const merged: Array<IoTFleet> = [...(input.incident.iotFleets || [])];
+
+      for (const id of input.clusterContext.iotFleetIds) {
+        if (existingIds.has(id)) {
+          continue;
+        }
+        const fleet: IoTFleet = new IoTFleet();
+        fleet._id = id;
+        merged.push(fleet);
+      }
+
+      input.incident.iotFleets = merged;
+    }
   }
 
   /*
@@ -1002,7 +1036,7 @@ export default class MonitorIncident {
 
     if (
       input.openIncident.createdCriteriaId?.toString() ===
-      input.criteriaInstance?.data?.id.toString()
+      input.criteriaInstance?.data?.id?.toString()
     ) {
       // same incident active. So, do not close.
       return false;