@oneuptime/common 10.4.17 → 10.5.0

package/Server/Services/Index.ts

@@ -104,7 +104,6 @@ import ScheduledMaintenanceStateTimelineService from "./ScheduledMaintenanceStat
 import ServiceOwnerTeamService from "./ServiceOwnerTeamService";
 import ServiceOwnerUserService from "./ServiceOwnerUserService";
 import ServiceService from "./ServiceService";
-import ServiceMonitorService from "./ServiceMonitorService";
 import ServiceCodeRepositoryService from "./ServiceCodeRepositoryService";
 import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
@@ -387,7 +386,6 @@ const services: Array<BaseService> = [
   ServiceService,
   ServiceOwnerTeamService,
   ServiceOwnerUserService,
-  ServiceMonitorService,
   ServiceCodeRepositoryService,
 
   TelemetryExceptionService,

package/Server/Services/MonitorProbeService.ts

@@ -18,6 +18,62 @@ export class Service extends DatabaseService<MonitorProbe> {
     super(MonitorProbe);
   }
 
+  public async pruneStaleLastMonitoringLogEntries(data: {
+    monitorId: ObjectID;
+    validMonitorStepIds: Array<string>;
+  }): Promise<void> {
+    const validIdSet: Set<string> = new Set(data.validMonitorStepIds);
+
+    const monitorProbes: Array<MonitorProbe> = await this.findBy({
+      query: {
+        monitorId: data.monitorId,
+      },
+      select: {
+        _id: true,
+        lastMonitoringLog: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const monitorProbe of monitorProbes) {
+      if (!monitorProbe.id || !monitorProbe.lastMonitoringLog) {
+        continue;
+      }
+
+      const existingLog: Record<string, unknown> =
+        monitorProbe.lastMonitoringLog as unknown as Record<string, unknown>;
+      const existingKeys: Array<string> = Object.keys(existingLog);
+      const prunedLog: Record<string, unknown> = {};
+      let removedAny: boolean = false;
+
+      for (const key of existingKeys) {
+        if (validIdSet.has(key)) {
+          prunedLog[key] = existingLog[key];
+        } else {
+          removedAny = true;
+        }
+      }
+
+      if (!removedAny) {
+        continue;
+      }
+
+      await this.updateOneById({
+        id: monitorProbe.id,
+        data: {
+          lastMonitoringLog: prunedLog as any,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+
   public async updateNextPingAtForMonitor(data: {
     monitorId: ObjectID;
   }): Promise<void> {

package/Server/Services/MonitorService.ts

@@ -155,6 +155,50 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  public extractMonitorStepIds(
+    monitorSteps: MonitorSteps | JSONObject,
+  ): Array<string> {
+    const stepIds: Array<string> = [];
+
+    let stepsArray: Array<MonitorStep | JSONObject> = [];
+
+    if (monitorSteps instanceof MonitorSteps) {
+      stepsArray = monitorSteps.data?.monitorStepsInstanceArray || [];
+    } else if (monitorSteps && typeof monitorSteps === "object") {
+      const value: JSONObject | undefined = (monitorSteps as JSONObject)[
+        "value"
+      ] as JSONObject | undefined;
+      const rawArray: unknown = value
+        ? value["monitorStepsInstanceArray"]
+        : (monitorSteps as JSONObject)["monitorStepsInstanceArray"];
+
+      if (Array.isArray(rawArray)) {
+        stepsArray = rawArray as Array<JSONObject>;
+      }
+    }
+
+    for (const step of stepsArray) {
+      let stepId: string | undefined;
+
+      if (step instanceof MonitorStep) {
+        stepId = step.data?.id;
+      } else if (step && typeof step === "object") {
+        const wrappedValue: JSONObject | undefined = (step as JSONObject)[
+          "value"
+        ] as JSONObject | undefined;
+        stepId = (wrappedValue?.["id"] || (step as JSONObject)["id"]) as
+          | string
+          | undefined;
+      }
+
+      if (stepId) {
+        stepIds.push(stepId.toString());
+      }
+    }
+
+    return stepIds;
+  }
+
   public async refreshMonitorCurrentStatus(monitorId: ObjectID): Promise<void> {
     const monitor: Model | null = await this.findOneById({
       id: monitorId,
@@ -363,6 +407,17 @@ export class Service extends DatabaseService<Model> {
           });
         }
 
+        if (onUpdate.updateBy.data.monitorSteps) {
+          const validMonitorStepIds: Array<string> = this.extractMonitorStepIds(
+            onUpdate.updateBy.data.monitorSteps as MonitorSteps | JSONObject,
+          );
+
+          await MonitorProbeService.pruneStaleLastMonitoringLogEntries({
+            monitorId: monitorId,
+            validMonitorStepIds: validMonitorStepIds,
+          });
+        }
+
         if (onUpdate.updateBy.data.name) {
           // add monitor feed.
 

package/Server/Services/ProjectService.ts

@@ -775,14 +775,23 @@ export class ProjectService extends DatabaseService<Model> {
       }
     }
 
-    createdItem = await this.addDefaultIncidentSeverity(createdItem);
-    createdItem = await this.addDefaultAlertSeverity(createdItem);
-    createdItem = await this.addDefaultProjectTeams(createdItem);
-    createdItem = await this.addDefaultMonitorStatus(createdItem);
-    createdItem = await this.addDefaultIncidentState(createdItem);
-    createdItem = await this.addDefaultScheduledMaintenanceState(createdItem);
-    createdItem = await this.addDefaultAlertState(createdItem);
-    createdItem = await this.addDefaultIncidentRoles(createdItem);
+    /*
+     * Each addDefault* method only reads `createdItem.id` and writes rows to a
+     * distinct table; none of them mutate `createdItem`. Running them in
+     * parallel cuts the onCreate hook latency from sum-of-8 sequential DB
+     * round-trips to max-of-8, which removes ~hundreds of ms on project
+     * create.
+     */
+    await Promise.all([
+      this.addDefaultIncidentSeverity(createdItem),
+      this.addDefaultAlertSeverity(createdItem),
+      this.addDefaultProjectTeams(createdItem),
+      this.addDefaultMonitorStatus(createdItem),
+      this.addDefaultIncidentState(createdItem),
+      this.addDefaultScheduledMaintenanceState(createdItem),
+      this.addDefaultAlertState(createdItem),
+      this.addDefaultIncidentRoles(createdItem),
+    ]);
 
     if (NotificationSlackWebhookOnCreateProject) {
       // fetch project again.

package/Server/Services/ScheduledMaintenanceLabelRuleEngineService.ts

@@ -1,9 +1,17 @@
+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 ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
 import ScheduledMaintenanceLabelRule from "../../Models/DatabaseModels/ScheduledMaintenanceLabelRule";
+import Service from "../../Models/DatabaseModels/Service";
+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 ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import ScheduledMaintenanceLabelRuleService from "./ScheduledMaintenanceLabelRuleService";
 import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
@@ -21,6 +29,10 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
    * attaches matched labels to the event. Each matched rule contributes:
    *   - labels listed on `labelsToAdd`
    *   - all labels of the event's monitors when `inheritLabelsFromMonitors`
+   *   - all labels of the event's hosts when `inheritLabelsFromHosts`
+   *   - all labels of the event's Kubernetes clusters when `inheritLabelsFromKubernetesClusters`
+   *   - all labels of the event's Docker hosts when `inheritLabelsFromDockerHosts`
+   *   - all labels of the event's services when `inheritLabelsFromServices`
    * The union is deduped against labels already on the event before insert
    * to avoid PK conflicts on the ScheduledMaintenanceLabel join table.
    */
@@ -52,6 +64,10 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
             monitorDescriptionPattern: true,
             labelsToAdd: { _id: true },
             inheritLabelsFromMonitors: true,
+            inheritLabelsFromHosts: true,
+            inheritLabelsFromKubernetesClusters: true,
+            inheritLabelsFromDockerHosts: true,
+            inheritLabelsFromServices: true,
           },
           limit: 100,
           skip: 0,
@@ -63,6 +79,10 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
 
       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<ScheduledMaintenanceLabelRule> = [];
 
       for (const rule of rules) {
@@ -82,6 +102,38 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
         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 eventWithResources: ScheduledMaintenance | null = null;
+      if (needsRelatedResources) {
+        eventWithResources = await ScheduledMaintenanceService.findOneById({
+          id: scheduledMaintenance.id,
+          select: {
+            hosts: { _id: true },
+            kubernetesClusters: { _id: true },
+            dockerHosts: { _id: true },
+            services: { _id: true },
+          },
+          props: { isRoot: true },
+        });
       }
 
       if (inheritFromMonitors && scheduledMaintenance.monitors?.length) {
@@ -102,6 +154,83 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromHosts && eventWithResources?.hosts?.length) {
+        for (const eventHost of eventWithResources.hosts) {
+          if (!eventHost.id) {
+            continue;
+          }
+          const host: Host | null = await HostService.findOneById({
+            id: eventHost.id,
+            select: { labels: { _id: true } },
+            props: { isRoot: true },
+          });
+          for (const label of host?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (
+        inheritFromKubernetesClusters &&
+        eventWithResources?.kubernetesClusters?.length
+      ) {
+        for (const eventCluster of eventWithResources.kubernetesClusters) {
+          if (!eventCluster.id) {
+            continue;
+          }
+          const cluster: KubernetesCluster | null =
+            await KubernetesClusterService.findOneById({
+              id: eventCluster.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of cluster?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromDockerHosts && eventWithResources?.dockerHosts?.length) {
+        for (const eventDockerHost of eventWithResources.dockerHosts) {
+          if (!eventDockerHost.id) {
+            continue;
+          }
+          const dockerHost: DockerHost | null =
+            await DockerHostService.findOneById({
+              id: eventDockerHost.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of dockerHost?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
+      if (inheritFromServices && eventWithResources?.services?.length) {
+        for (const eventService of eventWithResources.services) {
+          if (!eventService.id) {
+            continue;
+          }
+          const service: Service | null = await ServiceService.findOneById({
+            id: eventService.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;
       }