@oneuptime/common 10.4.17 → 10.5.1

package/Server/Services/IncidentGroupingEngineService.ts

@@ -11,7 +11,6 @@ import IncidentEpisodeRoleMember from "../../Models/DatabaseModels/IncidentEpiso
 import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
-import ServiceMonitor from "../../Models/DatabaseModels/ServiceMonitor";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
@@ -24,7 +23,6 @@ import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
 import IncidentEpisodeOwnerTeamService from "./IncidentEpisodeOwnerTeamService";
 import IncidentEpisodeRoleMemberService from "./IncidentEpisodeRoleMemberService";
 import MonitorService from "./MonitorService";
-import ServiceMonitorService from "./ServiceMonitorService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
 import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
@@ -95,7 +93,6 @@ class IncidentGroupingEngineServiceClass {
             groupByMonitor: true,
             groupBySeverity: true,
             groupByIncidentTitle: true,
-            groupByService: true,
             // Time settings
             enableTimeWindow: true,
             timeWindowMinutes: true,
@@ -589,37 +586,6 @@ class IncidentGroupingEngineServiceClass {
   ): Promise<string> {
     const parts: Array<string> = [];
 
-    /*
-     * Group by service - only if explicitly enabled
-     * Must be checked before monitor since service contains multiple monitors
-     */
-    if (
-      rule.groupByService &&
-      incident.monitors &&
-      incident.monitors.length > 0
-    ) {
-      // Use the first monitor's service for grouping
-      const firstMonitor: Monitor | undefined = incident.monitors[0];
-      if (firstMonitor && firstMonitor.id) {
-        const serviceMonitor: ServiceMonitor | null =
-          await ServiceMonitorService.findOneBy({
-            query: {
-              monitorId: firstMonitor.id,
-            },
-            select: {
-              serviceId: true,
-            },
-            props: {
-              isRoot: true,
-            },
-          });
-
-        if (serviceMonitor?.serviceId) {
-          parts.push(`service:${serviceMonitor.serviceId.toString()}`);
-        }
-      }
-    }
-
     // Group by monitor - only if explicitly enabled
     if (
       rule.groupByMonitor &&
@@ -921,9 +887,6 @@ class IncidentGroupingEngineServiceClass {
         if (rule.groupByIncidentTitle) {
           groupByParts.push("Incident Title");
         }
-        if (rule.groupByService) {
-          groupByParts.push("Service");
-        }
 
         const groupByDescription: string =
           groupByParts.length > 0

package/Server/Services/IncidentLabelRuleEngineService.ts

@@ -1,15 +1,21 @@
+import DockerHost from "../../Models/DatabaseModels/DockerHost";
 import Host from "../../Models/DatabaseModels/Host";
 import Incident from "../../Models/DatabaseModels/Incident";
 import IncidentLabelRule from "../../Models/DatabaseModels/IncidentLabelRule";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
+import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
 import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
+import Service from "../../Models/DatabaseModels/Service";
+import DockerHostService from "./DockerHostService";
 import HostService from "./HostService";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentLabelRuleService from "./IncidentLabelRuleService";
 import IncidentService from "./IncidentService";
+import KubernetesClusterService from "./KubernetesClusterService";
 import LabelService from "./LabelService";
 import MonitorService from "./MonitorService";
+import ServiceService from "./ServiceService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import { Indigo500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
@@ -25,6 +31,9 @@ class IncidentLabelRuleEngineServiceClass {
    *   - labels listed on `labelsToAdd`
    *   - all labels of the incident's monitors when `inheritLabelsFromMonitors`
    *   - all labels of the incident's hosts when `inheritLabelsFromHosts`
+   *   - all labels of the incident's Kubernetes clusters when `inheritLabelsFromKubernetesClusters`
+   *   - all labels of the incident's Docker hosts when `inheritLabelsFromDockerHosts`
+   *   - all labels of the incident's services when `inheritLabelsFromServices`
    * The union is deduped against labels already on the incident before insert
    * to avoid PK conflicts on the IncidentLabel join table.
    */
@@ -56,6 +65,9 @@ class IncidentLabelRuleEngineServiceClass {
             labelsToAdd: { _id: true },
             inheritLabelsFromMonitors: true,
             inheritLabelsFromHosts: true,
+            inheritLabelsFromKubernetesClusters: true,
+            inheritLabelsFromDockerHosts: true,
+            inheritLabelsFromServices: true,
           },
           limit: 100,
           skip: 0,
@@ -68,6 +80,9 @@ class IncidentLabelRuleEngineServiceClass {
       const labelIdsToAdd: Set<string> = new Set();
       let inheritFromMonitors: boolean = false;
       let inheritFromHosts: boolean = false;
+      let inheritFromKubernetesClusters: boolean = false;
+      let inheritFromDockerHosts: boolean = false;
+      let inheritFromServices: boolean = false;
       const matchedRules: Array<IncidentLabelRule> = [];
 
       for (const rule of rules) {
@@ -90,6 +105,15 @@ class IncidentLabelRuleEngineServiceClass {
         if (rule.inheritLabelsFromHosts) {
           inheritFromHosts = true;
         }
+        if (rule.inheritLabelsFromKubernetesClusters) {
+          inheritFromKubernetesClusters = true;
+        }
+        if (rule.inheritLabelsFromDockerHosts) {
+          inheritFromDockerHosts = true;
+        }
+        if (rule.inheritLabelsFromServices) {
+          inheritFromServices = true;
+        }
       }
 
       if (inheritFromMonitors && incident.monitors?.length) {
@@ -128,6 +152,65 @@ class IncidentLabelRuleEngineServiceClass {
         }
       }
 
+      if (
+        inheritFromKubernetesClusters &&
+        incident.kubernetesClusters?.length
+      ) {
+        for (const incidentCluster of incident.kubernetesClusters) {
+          if (!incidentCluster.id) {
+            continue;
+          }
+          const cluster: KubernetesCluster | null =
+            await KubernetesClusterService.findOneById({
+              id: incidentCluster.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of cluster?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromDockerHosts && incident.dockerHosts?.length) {
+        for (const incidentDockerHost of incident.dockerHosts) {
+          if (!incidentDockerHost.id) {
+            continue;
+          }
+          const dockerHost: DockerHost | null =
+            await DockerHostService.findOneById({
+              id: incidentDockerHost.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of dockerHost?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromServices && incident.services?.length) {
+        for (const incidentService of incident.services) {
+          if (!incidentService.id) {
+            continue;
+          }
+          const service: Service | null = await ServiceService.findOneById({
+            id: incidentService.id,
+            select: { labels: { _id: true } },
+            props: { isRoot: true },
+          });
+          for (const label of service?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
       if (labelIdsToAdd.size === 0) {
         return;
       }

package/Server/Services/IncidentOwnerRuleEngineService.ts

@@ -1,23 +1,38 @@
+import DockerHost from "../../Models/DatabaseModels/DockerHost";
+import DockerHostOwnerTeam from "../../Models/DatabaseModels/DockerHostOwnerTeam";
+import DockerHostOwnerUser from "../../Models/DatabaseModels/DockerHostOwnerUser";
 import Host from "../../Models/DatabaseModels/Host";
 import HostOwnerTeam from "../../Models/DatabaseModels/HostOwnerTeam";
 import HostOwnerUser from "../../Models/DatabaseModels/HostOwnerUser";
 import Incident from "../../Models/DatabaseModels/Incident";
 import IncidentOwnerRule from "../../Models/DatabaseModels/IncidentOwnerRule";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
+import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
+import KubernetesClusterOwnerTeam from "../../Models/DatabaseModels/KubernetesClusterOwnerTeam";
+import KubernetesClusterOwnerUser from "../../Models/DatabaseModels/KubernetesClusterOwnerUser";
 import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import MonitorOwnerTeam from "../../Models/DatabaseModels/MonitorOwnerTeam";
 import MonitorOwnerUser from "../../Models/DatabaseModels/MonitorOwnerUser";
+import Service from "../../Models/DatabaseModels/Service";
+import ServiceOwnerTeam from "../../Models/DatabaseModels/ServiceOwnerTeam";
+import ServiceOwnerUser from "../../Models/DatabaseModels/ServiceOwnerUser";
 import Team from "../../Models/DatabaseModels/Team";
 import User from "../../Models/DatabaseModels/User";
+import DockerHostOwnerTeamService from "./DockerHostOwnerTeamService";
+import DockerHostOwnerUserService from "./DockerHostOwnerUserService";
 import HostOwnerTeamService from "./HostOwnerTeamService";
 import HostOwnerUserService from "./HostOwnerUserService";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentOwnerRuleService from "./IncidentOwnerRuleService";
 import IncidentService from "./IncidentService";
+import KubernetesClusterOwnerTeamService from "./KubernetesClusterOwnerTeamService";
+import KubernetesClusterOwnerUserService from "./KubernetesClusterOwnerUserService";
 import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
 import MonitorOwnerUserService from "./MonitorOwnerUserService";
 import MonitorService from "./MonitorService";
+import ServiceOwnerTeamService from "./ServiceOwnerTeamService";
+import ServiceOwnerUserService from "./ServiceOwnerUserService";
 import TeamService from "./TeamService";
 import UserService from "./UserService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
@@ -64,6 +79,9 @@ class IncidentOwnerRuleEngineServiceClass {
             ownerTeams: { _id: true },
             inheritOwnersFromMonitors: true,
             inheritOwnersFromHosts: true,
+            inheritOwnersFromKubernetesClusters: true,
+            inheritOwnersFromDockerHosts: true,
+            inheritOwnersFromServices: true,
           },
           limit: 100,
           skip: 0,
@@ -73,10 +91,6 @@ class IncidentOwnerRuleEngineServiceClass {
         return;
       }
 
-      /*
-       * Collect owners by notify-mode so we can call addOwners with the
-       * correct notification flag.
-       */
       const usersByNotify: Map<boolean, Set<string>> = new Map([
         [true, new Set()],
         [false, new Set()],
@@ -91,6 +105,9 @@ class IncidentOwnerRuleEngineServiceClass {
       const allTeamIds: Set<string> = new Set();
       let inheritFromMonitors: boolean = false;
       let inheritFromHosts: boolean = false;
+      let inheritFromKubernetesClusters: boolean = false;
+      let inheritFromDockerHosts: boolean = false;
+      let inheritFromServices: boolean = false;
       const inheritNotifyMode: { value: boolean | null } = { value: null };
 
       for (const rule of rules) {
@@ -120,11 +137,6 @@ class IncidentOwnerRuleEngineServiceClass {
         if (rule.inheritOwnersFromMonitors) {
           inheritFromMonitors = true;
           ruleAddedAny = true;
-          /*
-           * If multiple matching rules ask to inherit, prefer notify=true so
-           * any rule that wants to notify wins. This matches the spirit of
-           * notifyOwners — once any rule has opted in, owners are notified.
-           */
           inheritNotifyMode.value =
             inheritNotifyMode.value === true ? true : notify;
         }
@@ -134,6 +146,24 @@ class IncidentOwnerRuleEngineServiceClass {
           inheritNotifyMode.value =
             inheritNotifyMode.value === true ? true : notify;
         }
+        if (rule.inheritOwnersFromKubernetesClusters) {
+          inheritFromKubernetesClusters = true;
+          ruleAddedAny = true;
+          inheritNotifyMode.value =
+            inheritNotifyMode.value === true ? true : notify;
+        }
+        if (rule.inheritOwnersFromDockerHosts) {
+          inheritFromDockerHosts = true;
+          ruleAddedAny = true;
+          inheritNotifyMode.value =
+            inheritNotifyMode.value === true ? true : notify;
+        }
+        if (rule.inheritOwnersFromServices) {
+          inheritFromServices = true;
+          ruleAddedAny = true;
+          inheritNotifyMode.value =
+            inheritNotifyMode.value === true ? true : notify;
+        }
         if (ruleAddedAny) {
           matchedRules.push(rule);
         }
@@ -143,6 +173,12 @@ class IncidentOwnerRuleEngineServiceClass {
       const inheritedFromMonitorTeamIds: Set<string> = new Set();
       const inheritedFromHostUserIds: Set<string> = new Set();
       const inheritedFromHostTeamIds: Set<string> = new Set();
+      const inheritedFromKubernetesClusterUserIds: Set<string> = new Set();
+      const inheritedFromKubernetesClusterTeamIds: Set<string> = new Set();
+      const inheritedFromDockerHostUserIds: Set<string> = new Set();
+      const inheritedFromDockerHostTeamIds: Set<string> = new Set();
+      const inheritedFromServiceUserIds: Set<string> = new Set();
+      const inheritedFromServiceTeamIds: Set<string> = new Set();
 
       if (inheritFromMonitors && incident.monitors?.length) {
         const monitorIds: Array<ObjectID> = incident.monitors
@@ -226,13 +262,149 @@ class IncidentOwnerRuleEngineServiceClass {
         }
       }
 
+      if (
+        inheritFromKubernetesClusters &&
+        incident.kubernetesClusters?.length
+      ) {
+        const clusterIds: Array<ObjectID> = incident.kubernetesClusters
+          .map((c: KubernetesCluster) => {
+            return c.id;
+          })
+          .filter((id: ObjectID | null | undefined): id is ObjectID => {
+            return Boolean(id);
+          });
+        if (clusterIds.length > 0) {
+          const [clusterOwnerUsers, clusterOwnerTeams]: [
+            Array<KubernetesClusterOwnerUser>,
+            Array<KubernetesClusterOwnerTeam>,
+          ] = await Promise.all([
+            KubernetesClusterOwnerUserService.findBy({
+              query: { kubernetesClusterId: QueryHelper.any(clusterIds) },
+              select: { userId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+            KubernetesClusterOwnerTeamService.findBy({
+              query: { kubernetesClusterId: QueryHelper.any(clusterIds) },
+              select: { teamId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+          ]);
+          for (const ownerUser of clusterOwnerUsers) {
+            if (ownerUser.userId) {
+              inheritedFromKubernetesClusterUserIds.add(
+                ownerUser.userId.toString(),
+              );
+            }
+          }
+          for (const ownerTeam of clusterOwnerTeams) {
+            if (ownerTeam.teamId) {
+              inheritedFromKubernetesClusterTeamIds.add(
+                ownerTeam.teamId.toString(),
+              );
+            }
+          }
+        }
+      }
+
+      if (inheritFromDockerHosts && incident.dockerHosts?.length) {
+        const dockerHostIds: Array<ObjectID> = incident.dockerHosts
+          .map((d: DockerHost) => {
+            return d.id;
+          })
+          .filter((id: ObjectID | null | undefined): id is ObjectID => {
+            return Boolean(id);
+          });
+        if (dockerHostIds.length > 0) {
+          const [dockerHostOwnerUsers, dockerHostOwnerTeams]: [
+            Array<DockerHostOwnerUser>,
+            Array<DockerHostOwnerTeam>,
+          ] = await Promise.all([
+            DockerHostOwnerUserService.findBy({
+              query: { dockerHostId: QueryHelper.any(dockerHostIds) },
+              select: { userId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+            DockerHostOwnerTeamService.findBy({
+              query: { dockerHostId: QueryHelper.any(dockerHostIds) },
+              select: { teamId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+          ]);
+          for (const ownerUser of dockerHostOwnerUsers) {
+            if (ownerUser.userId) {
+              inheritedFromDockerHostUserIds.add(ownerUser.userId.toString());
+            }
+          }
+          for (const ownerTeam of dockerHostOwnerTeams) {
+            if (ownerTeam.teamId) {
+              inheritedFromDockerHostTeamIds.add(ownerTeam.teamId.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromServices && incident.services?.length) {
+        const serviceIds: Array<ObjectID> = incident.services
+          .map((s: Service) => {
+            return s.id;
+          })
+          .filter((id: ObjectID | null | undefined): id is ObjectID => {
+            return Boolean(id);
+          });
+        if (serviceIds.length > 0) {
+          const [serviceOwnerUsers, serviceOwnerTeams]: [
+            Array<ServiceOwnerUser>,
+            Array<ServiceOwnerTeam>,
+          ] = await Promise.all([
+            ServiceOwnerUserService.findBy({
+              query: { serviceId: QueryHelper.any(serviceIds) },
+              select: { userId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+            ServiceOwnerTeamService.findBy({
+              query: { serviceId: QueryHelper.any(serviceIds) },
+              select: { teamId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+          ]);
+          for (const ownerUser of serviceOwnerUsers) {
+            if (ownerUser.userId) {
+              inheritedFromServiceUserIds.add(ownerUser.userId.toString());
+            }
+          }
+          for (const ownerTeam of serviceOwnerTeams) {
+            if (ownerTeam.teamId) {
+              inheritedFromServiceTeamIds.add(ownerTeam.teamId.toString());
+            }
+          }
+        }
+      }
+
       const inheritedUserIds: Set<string> = new Set([
         ...inheritedFromMonitorUserIds,
         ...inheritedFromHostUserIds,
+        ...inheritedFromKubernetesClusterUserIds,
+        ...inheritedFromDockerHostUserIds,
+        ...inheritedFromServiceUserIds,
       ]);
       const inheritedTeamIds: Set<string> = new Set([
         ...inheritedFromMonitorTeamIds,
         ...inheritedFromHostTeamIds,
+        ...inheritedFromKubernetesClusterTeamIds,
+        ...inheritedFromDockerHostTeamIds,
+        ...inheritedFromServiceTeamIds,
       ]);
 
       if (inheritedUserIds.size > 0 || inheritedTeamIds.size > 0) {
@@ -296,6 +468,17 @@ class IncidentOwnerRuleEngineServiceClass {
           0,
         inheritedFromHosts:
           inheritedFromHostUserIds.size + inheritedFromHostTeamIds.size > 0,
+        inheritedFromKubernetesClusters:
+          inheritedFromKubernetesClusterUserIds.size +
+            inheritedFromKubernetesClusterTeamIds.size >
+          0,
+        inheritedFromDockerHosts:
+          inheritedFromDockerHostUserIds.size +
+            inheritedFromDockerHostTeamIds.size >
+          0,
+        inheritedFromServices:
+          inheritedFromServiceUserIds.size + inheritedFromServiceTeamIds.size >
+          0,
       });
     } catch (error) {
       logger.error(`Error applying incident owner rules: ${error}`, {
@@ -313,6 +496,9 @@ class IncidentOwnerRuleEngineServiceClass {
     teamIds: Array<string>;
     inheritedFromMonitors: boolean;
     inheritedFromHosts: boolean;
+    inheritedFromKubernetesClusters: boolean;
+    inheritedFromDockerHosts: boolean;
+    inheritedFromServices: boolean;
   }): Promise<void> {
     const {
       incident,
@@ -321,6 +507,9 @@ class IncidentOwnerRuleEngineServiceClass {
       teamIds,
       inheritedFromMonitors,
       inheritedFromHosts,
+      inheritedFromKubernetesClusters,
+      inheritedFromDockerHosts,
+      inheritedFromServices,
     } = data;
     if (
       !incident.id ||
@@ -398,9 +587,18 @@ class IncidentOwnerRuleEngineServiceClass {
       if (inheritedFromHosts) {
         inheritedSources.push("hosts");
       }
+      if (inheritedFromKubernetesClusters) {
+        inheritedSources.push("Kubernetes clusters");
+      }
+      if (inheritedFromDockerHosts) {
+        inheritedSources.push("Docker hosts");
+      }
+      if (inheritedFromServices) {
+        inheritedSources.push("services");
+      }
       const inheritedNote: string =
         inheritedSources.length > 0
-          ? `\n\n_Some owners were inherited from the incident's ${inheritedSources.join(" and ")}._`
+          ? `\n\n_Some owners were inherited from the incident's ${inheritedSources.join(", ")}._`
           : "";
 
       const feedInfoInMarkdown: string = `🛡️ **Incident Owner Rule${

package/Server/Services/IncidentService.ts

@@ -28,6 +28,10 @@ import Typeof from "../../Types/Typeof";
 import { applyIncidentSelfPrivacyFilter } from "../Utils/Incident/IncidentPrivacyFilter";
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import DockerHost from "../../Models/DatabaseModels/DockerHost";
+import Host from "../../Models/DatabaseModels/Host";
+import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
+import ServiceModel from "../../Models/DatabaseModels/Service";
 import Model from "../../Models/DatabaseModels/Incident";
 import IncidentOwnerTeam from "../../Models/DatabaseModels/IncidentOwnerTeam";
 import IncidentOwnerUser from "../../Models/DatabaseModels/IncidentOwnerUser";
@@ -541,7 +545,16 @@ export class Service extends DatabaseService<Model> {
         );
       }
     } else if (createBy.data.createdIncidentTemplateId) {
-      // If created from a template, check if template has a custom initial state
+      /*
+       * Created from a template — pull every field we may want to
+       * inherit and apply each one only if the caller didn't already
+       * provide it. The dashboard pre-fills these on the client, so in
+       * the UI flow this is a no-op; the gain is for API consumers
+       * that just send `createdIncidentTemplateId` and expect the
+       * server to materialize the rest. `undefined` means "not set by
+       * the caller" — an explicit empty array or empty string is
+       * treated as an intentional override and we leave it alone.
+       */
       const incidentTemplate: IncidentTemplate | null =
         await IncidentTemplateService.findOneBy({
           query: {
@@ -550,6 +563,17 @@ export class Service extends DatabaseService<Model> {
           },
           select: {
             initialIncidentStateId: true,
+            incidentSeverityId: true,
+            changeMonitorStatusToId: true,
+            title: true,
+            description: true,
+            monitors: { _id: true },
+            hosts: { _id: true },
+            kubernetesClusters: { _id: true },
+            dockerHosts: { _id: true },
+            services: { _id: true },
+            onCallDutyPolicies: { _id: true },
+            labels: { _id: true },
           },
           props: {
             isRoot: true,
@@ -579,6 +603,120 @@ export class Service extends DatabaseService<Model> {
           initialIncidentStateId = undefined;
         }
       }
+
+      if (incidentTemplate) {
+        if (
+          createBy.data.incidentSeverityId === undefined &&
+          incidentTemplate.incidentSeverityId
+        ) {
+          createBy.data.incidentSeverityId =
+            incidentTemplate.incidentSeverityId;
+        }
+        if (
+          createBy.data.changeMonitorStatusToId === undefined &&
+          incidentTemplate.changeMonitorStatusToId
+        ) {
+          createBy.data.changeMonitorStatusToId =
+            incidentTemplate.changeMonitorStatusToId;
+        }
+        if (
+          createBy.data.title === undefined &&
+          typeof incidentTemplate.title === "string"
+        ) {
+          createBy.data.title = incidentTemplate.title;
+        }
+        if (
+          createBy.data.description === undefined &&
+          typeof incidentTemplate.description === "string"
+        ) {
+          createBy.data.description = incidentTemplate.description;
+        }
+
+        const stubBy: <T extends { _id?: string | undefined }>(
+          ctor: new () => T,
+          rows: Array<{ _id?: string | undefined }> | undefined,
+        ) => Array<T> | undefined = <T extends { _id?: string | undefined }>(
+          ctor: new () => T,
+          rows: Array<{ _id?: string | undefined }> | undefined,
+        ): Array<T> | undefined => {
+          if (!rows) {
+            return undefined;
+          }
+          return rows
+            .filter((row: { _id?: string | undefined }): boolean => {
+              return Boolean(row._id);
+            })
+            .map((row: { _id?: string | undefined }): T => {
+              const stub: T = new ctor();
+              stub._id = String(row._id);
+              return stub;
+            });
+        };
+
+        if (createBy.data.monitors === undefined) {
+          const stubs: Array<Monitor> | undefined = stubBy(
+            Monitor,
+            incidentTemplate.monitors,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.monitors = stubs;
+          }
+        }
+        if (createBy.data.hosts === undefined) {
+          const stubs: Array<Host> | undefined = stubBy(
+            Host,
+            incidentTemplate.hosts,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.hosts = stubs;
+          }
+        }
+        if (createBy.data.kubernetesClusters === undefined) {
+          const stubs: Array<KubernetesCluster> | undefined = stubBy(
+            KubernetesCluster,
+            incidentTemplate.kubernetesClusters,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.kubernetesClusters = stubs;
+          }
+        }
+        if (createBy.data.dockerHosts === undefined) {
+          const stubs: Array<DockerHost> | undefined = stubBy(
+            DockerHost,
+            incidentTemplate.dockerHosts,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.dockerHosts = stubs;
+          }
+        }
+        if (createBy.data.services === undefined) {
+          const stubs: Array<ServiceModel> | undefined = stubBy(
+            ServiceModel,
+            incidentTemplate.services,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.services = stubs;
+          }
+        }
+        if (createBy.data.onCallDutyPolicies === undefined) {
+          const stubs: Array<OnCallDutyPolicy> | undefined = stubBy(
+            OnCallDutyPolicy,
+            incidentTemplate.onCallDutyPolicies,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.onCallDutyPolicies = stubs;
+          }
+        }
+        if (createBy.data.labels === undefined) {
+          const stubs: Array<Label> | undefined = stubBy(
+            Label,
+            incidentTemplate.labels,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.labels = stubs;
+          }
+        }
+      }
     }
 
     // If no custom state is provided or found, fall back to default created state