@oneuptime/common 10.4.17 → 10.5.1

package/Server/Infrastructure/Postgres/SchemaMigrations/1779827700000-RenameStatusPageZhToZhCN.ts

@@ -0,0 +1,62 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Data-only migration: the language code "zh" was renamed to "zh-CN" when
+ * Traditional Chinese ("zh-TW") was added as a separate supported language.
+ * Rewrite any persisted "zh" values on the StatusPage table so existing
+ * tenants keep their Simplified Chinese setting.
+ *
+ * Written manually because typeorm's migration:generate only emits schema
+ * diffs — it cannot detect that stored data needs rewriting.
+ */
+export class RenameStatusPageZhToZhCN1779827700000
+  implements MigrationInterface
+{
+  public name: string = "RenameStatusPageZhToZhCN1779827700000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // defaultLanguage is a varchar — straight UPDATE.
+    await queryRunner.query(
+      `UPDATE "StatusPage" SET "defaultLanguage" = 'zh-CN' WHERE "defaultLanguage" = 'zh'`,
+    );
+
+    /*
+     * enabledLanguages is a jsonb array of strings. Replace every "zh"
+     * element with "zh-CN" while leaving the rest of the array intact.
+     * The WHERE clause uses jsonb containment so we only touch rows that
+     * actually need rewriting.
+     */
+    await queryRunner.query(
+      `UPDATE "StatusPage"
+       SET "enabledLanguages" = (
+         SELECT jsonb_agg(
+           CASE WHEN elem = '"zh"'::jsonb THEN '"zh-CN"'::jsonb ELSE elem END
+         )
+         FROM jsonb_array_elements("enabledLanguages") AS elem
+       )
+       WHERE "enabledLanguages" @> '["zh"]'::jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Best-effort reversal. "zh-CN" did not exist before this migration, so
+     * any row containing it was originally "zh"; rows added after the
+     * migration that legitimately use "zh-CN" will be reverted too, which is
+     * the inherent limitation of rolling back data migrations.
+     */
+    await queryRunner.query(
+      `UPDATE "StatusPage" SET "defaultLanguage" = 'zh' WHERE "defaultLanguage" = 'zh-CN'`,
+    );
+    await queryRunner.query(
+      `UPDATE "StatusPage"
+       SET "enabledLanguages" = (
+         SELECT jsonb_agg(
+           CASE WHEN elem = '"zh-CN"'::jsonb THEN '"zh"'::jsonb ELSE elem END
+         )
+         FROM jsonb_array_elements("enabledLanguages") AS elem
+       )
+       WHERE "enabledLanguages" @> '["zh-CN"]'::jsonb`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -347,6 +347,13 @@ import { AddPerformanceIndexes1779392970424 } from "./1779392970424-AddPerforman
 import { AddFacetsToTableView1779536271671 } from "./1779536271671-AddFacetsToTableView";
 import { AddIsMemberNotifiedIndex1779540427366 } from "./1779540427366-AddIsMemberNotifiedIndex";
 import { AddDropdownOptionsToCustomFields1779619108628 } from "./1779619108628-AddDropdownOptionsToCustomFields";
+import { AddLabelInheritanceAndScheduledMaintenanceResources1779653508434 } from "./1779653508434-AddLabelInheritanceAndScheduledMaintenanceResources";
+import { AddAffectedResourcesToTemplates1779708719656 } from "./1779708719656-AddAffectedResourcesToTemplates";
+import { MigrationName1779739410559 } from "./1779739410559-MigrationName";
+import { AttachServiceToScheduledMaintenanceTemplatesAndLabelRules1779742211961 } from "./1779742211961-AttachServiceToScheduledMaintenanceTemplatesAndLabelRules";
+import { MigrationName1779790539196 } from "./1779790539196-MigrationName";
+import { ExpandOwnerRuleInheritFlags1779823516881 } from "./1779823516881-ExpandOwnerRuleInheritFlags";
+import { RenameStatusPageZhToZhCN1779827700000 } from "./1779827700000-RenameStatusPageZhToZhCN";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -697,4 +704,11 @@ export default [
   AddFacetsToTableView1779536271671,
   AddIsMemberNotifiedIndex1779540427366,
   AddDropdownOptionsToCustomFields1779619108628,
+  AddLabelInheritanceAndScheduledMaintenanceResources1779653508434,
+  AddAffectedResourcesToTemplates1779708719656,
+  MigrationName1779739410559,
+  AttachServiceToScheduledMaintenanceTemplatesAndLabelRules1779742211961,
+  MigrationName1779790539196,
+  ExpandOwnerRuleInheritFlags1779823516881,
+  RenameStatusPageZhToZhCN1779827700000,
 ];

package/Server/Middleware/TelemetryIngestionDisabled.ts

@@ -0,0 +1,32 @@
+import { DisableTelemetryIngestion } from "../EnvironmentConfig";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+
+/*
+ * Short-circuit middleware for telemetry ingestion routes.
+ *
+ * When DISABLE_TELEMETRY_INGESTION=true, return a 200 success immediately
+ * so OTel / Fluent / Syslog / Pyroscope clients accept the response and do
+ * not retry. No body parsing, queueing, or persistence happens — the data
+ * is dropped on the floor.
+ */
+export default class TelemetryIngestionDisabled {
+  public static middleware(
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): void {
+    if (DisableTelemetryIngestion) {
+      return Response.sendEmptySuccessResponse(req, res);
+    }
+    return next();
+  }
+
+  public static isDisabled(): boolean {
+    return DisableTelemetryIngestion;
+  }
+}

package/Server/Services/AlertGroupingEngineService.ts

@@ -10,7 +10,6 @@ import AlertEpisodeOwnerTeam from "../../Models/DatabaseModels/AlertEpisodeOwner
 import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
-import ServiceMonitor from "../../Models/DatabaseModels/ServiceMonitor";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
@@ -22,7 +21,6 @@ import AlertEpisodeMemberService from "./AlertEpisodeMemberService";
 import AlertEpisodeOwnerUserService from "./AlertEpisodeOwnerUserService";
 import AlertEpisodeOwnerTeamService from "./AlertEpisodeOwnerTeamService";
 import MonitorService from "./MonitorService";
-import ServiceMonitorService from "./ServiceMonitorService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
 import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
@@ -93,7 +91,6 @@ class AlertGroupingEngineServiceClass {
             groupByMonitor: true,
             groupBySeverity: true,
             groupByAlertTitle: true,
-            groupByService: true,
             // Time settings
             enableTimeWindow: true,
             timeWindowMinutes: true,
@@ -539,29 +536,6 @@ class AlertGroupingEngineServiceClass {
   ): 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 && alert.monitorId) {
-      const serviceMonitor: ServiceMonitor | null =
-        await ServiceMonitorService.findOneBy({
-          query: {
-            monitorId: alert.monitorId,
-          },
-          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 && alert.monitorId) {
       parts.push(`monitor:${alert.monitorId.toString()}`);
@@ -819,9 +793,6 @@ class AlertGroupingEngineServiceClass {
         if (rule.groupByAlertTitle) {
           groupByParts.push("Alert Title");
         }
-        if (rule.groupByService) {
-          groupByParts.push("Service");
-        }
 
         const groupByDescription: string =
           groupByParts.length > 0

package/Server/Services/AlertLabelRuleEngineService.ts

@@ -1,13 +1,21 @@
 import Alert from "../../Models/DatabaseModels/Alert";
 import AlertLabelRule from "../../Models/DatabaseModels/AlertLabelRule";
 import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
+import DockerHost from "../../Models/DatabaseModels/DockerHost";
+import Host from "../../Models/DatabaseModels/Host";
+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 AlertFeedService from "./AlertFeedService";
 import AlertLabelRuleService from "./AlertLabelRuleService";
 import AlertService from "./AlertService";
+import DockerHostService from "./DockerHostService";
+import HostService from "./HostService";
+import KubernetesClusterService from "./KubernetesClusterService";
 import LabelService from "./LabelService";
 import MonitorService from "./MonitorService";
+import ServiceService from "./ServiceService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Indigo500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
@@ -22,6 +30,10 @@ class AlertLabelRuleEngineServiceClass {
    * labels to the alert. Each matched rule contributes:
    *   - labels listed on `labelsToAdd`
    *   - all labels of the alert's monitor when `inheritLabelsFromMonitors`
+   *   - all labels of the alert's hosts when `inheritLabelsFromHosts`
+   *   - all labels of the alert's Kubernetes clusters when `inheritLabelsFromKubernetesClusters`
+   *   - all labels of the alert's Docker hosts when `inheritLabelsFromDockerHosts`
+   *   - all labels of the alert's services when `inheritLabelsFromServices`
    * The union is deduped against labels already on the alert before insert
    * to avoid PK conflicts on the AlertLabel join table.
    */
@@ -51,6 +63,10 @@ class AlertLabelRuleEngineServiceClass {
           monitorDescriptionPattern: true,
           labelsToAdd: { _id: true },
           inheritLabelsFromMonitors: true,
+          inheritLabelsFromHosts: true,
+          inheritLabelsFromKubernetesClusters: true,
+          inheritLabelsFromDockerHosts: true,
+          inheritLabelsFromServices: true,
         },
         limit: 100,
         skip: 0,
@@ -62,6 +78,10 @@ class AlertLabelRuleEngineServiceClass {
 
       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<AlertLabelRule> = [];
 
       for (const rule of rules) {
@@ -78,6 +98,38 @@ class AlertLabelRuleEngineServiceClass {
         if (rule.inheritLabelsFromMonitors) {
           inheritFromMonitors = true;
         }
+        if (rule.inheritLabelsFromHosts) {
+          inheritFromHosts = true;
+        }
+        if (rule.inheritLabelsFromKubernetesClusters) {
+          inheritFromKubernetesClusters = true;
+        }
+        if (rule.inheritLabelsFromDockerHosts) {
+          inheritFromDockerHosts = true;
+        }
+        if (rule.inheritLabelsFromServices) {
+          inheritFromServices = true;
+        }
+      }
+
+      const needsRelatedResources: boolean =
+        inheritFromHosts ||
+        inheritFromKubernetesClusters ||
+        inheritFromDockerHosts ||
+        inheritFromServices;
+
+      let alertWithResources: Alert | null = null;
+      if (needsRelatedResources) {
+        alertWithResources = await AlertService.findOneById({
+          id: alert.id,
+          select: {
+            hosts: { _id: true },
+            kubernetesClusters: { _id: true },
+            dockerHosts: { _id: true },
+            services: { _id: true },
+          },
+          props: { isRoot: true },
+        });
       }
 
       if (inheritFromMonitors && alert.monitorId) {
@@ -93,6 +145,83 @@ class AlertLabelRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromHosts && alertWithResources?.hosts?.length) {
+        for (const alertHost of alertWithResources.hosts) {
+          if (!alertHost.id) {
+            continue;
+          }
+          const host: Host | null = await HostService.findOneById({
+            id: alertHost.id,
+            select: { labels: { _id: true } },
+            props: { isRoot: true },
+          });
+          for (const label of host?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (
+        inheritFromKubernetesClusters &&
+        alertWithResources?.kubernetesClusters?.length
+      ) {
+        for (const alertCluster of alertWithResources.kubernetesClusters) {
+          if (!alertCluster.id) {
+            continue;
+          }
+          const cluster: KubernetesCluster | null =
+            await KubernetesClusterService.findOneById({
+              id: alertCluster.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of cluster?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromDockerHosts && alertWithResources?.dockerHosts?.length) {
+        for (const alertDockerHost of alertWithResources.dockerHosts) {
+          if (!alertDockerHost.id) {
+            continue;
+          }
+          const dockerHost: DockerHost | null =
+            await DockerHostService.findOneById({
+              id: alertDockerHost.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of dockerHost?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromServices && alertWithResources?.services?.length) {
+        for (const alertService of alertWithResources.services) {
+          if (!alertService.id) {
+            continue;
+          }
+          const service: Service | null = await ServiceService.findOneById({
+            id: alertService.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/AlertOwnerRuleEngineService.ts

@@ -1,23 +1,38 @@
 import Alert from "../../Models/DatabaseModels/Alert";
 import AlertOwnerRule from "../../Models/DatabaseModels/AlertOwnerRule";
 import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
+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 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 AlertFeedService from "./AlertFeedService";
 import AlertOwnerRuleService from "./AlertOwnerRuleService";
 import AlertService from "./AlertService";
+import DockerHostOwnerTeamService from "./DockerHostOwnerTeamService";
+import DockerHostOwnerUserService from "./DockerHostOwnerUserService";
 import HostOwnerTeamService from "./HostOwnerTeamService";
 import HostOwnerUserService from "./HostOwnerUserService";
+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 { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
@@ -62,6 +77,9 @@ class AlertOwnerRuleEngineServiceClass {
           ownerTeams: { _id: true },
           inheritOwnersFromMonitors: true,
           inheritOwnersFromHosts: true,
+          inheritOwnersFromKubernetesClusters: true,
+          inheritOwnersFromDockerHosts: true,
+          inheritOwnersFromServices: true,
         },
         limit: 100,
         skip: 0,
@@ -85,6 +103,9 @@ class AlertOwnerRuleEngineServiceClass {
       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,6 +141,24 @@ class AlertOwnerRuleEngineServiceClass {
           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);
         }
@@ -129,6 +168,12 @@ class AlertOwnerRuleEngineServiceClass {
       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 && alert.monitorId) {
         const [monitorOwnerUsers, monitorOwnerTeams]: [
@@ -203,13 +248,146 @@ class AlertOwnerRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromKubernetesClusters && alert.kubernetesClusters?.length) {
+        const clusterIds: Array<ObjectID> = alert.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 && alert.dockerHosts?.length) {
+        const dockerHostIds: Array<ObjectID> = alert.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 && alert.services?.length) {
+        const serviceIds: Array<ObjectID> = alert.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) {
@@ -272,6 +450,17 @@ class AlertOwnerRuleEngineServiceClass {
           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 alert owner rules: ${error}`, {
@@ -289,6 +478,9 @@ class AlertOwnerRuleEngineServiceClass {
     teamIds: Array<string>;
     inheritedFromMonitors: boolean;
     inheritedFromHosts: boolean;
+    inheritedFromKubernetesClusters: boolean;
+    inheritedFromDockerHosts: boolean;
+    inheritedFromServices: boolean;
   }): Promise<void> {
     const {
       alert,
@@ -297,6 +489,9 @@ class AlertOwnerRuleEngineServiceClass {
       teamIds,
       inheritedFromMonitors,
       inheritedFromHosts,
+      inheritedFromKubernetesClusters,
+      inheritedFromDockerHosts,
+      inheritedFromServices,
     } = data;
     if (
       !alert.id ||
@@ -374,9 +569,18 @@ class AlertOwnerRuleEngineServiceClass {
       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 alert's ${inheritedSources.join(" and ")}._`
+          ? `\n\n_Some owners were inherited from the alert's ${inheritedSources.join(", ")}._`
           : "";
 
       const feedInfoInMarkdown: string = `🛡️ **Alert Owner Rule${