@oneuptime/common 11.4.0 → 11.5.0

package/Server/Services/MonitorService.ts

@@ -121,7 +121,10 @@ export class Service extends DatabaseService<Model> {
         }
 
         // For SNMP monitors, use the hostname from snmpMonitor config
-        if (monitorType === MonitorType.SNMP && firstStep?.data?.snmpMonitor) {
+        if (
+          monitorType === MonitorType.NetworkDevice &&
+          firstStep?.data?.snmpMonitor
+        ) {
           monitorDestination = firstStep.data.snmpMonitor.hostname || "";
           const port: number = firstStep.data.snmpMonitor.port || 161;
           if (monitorDestination && port) {

package/Server/Services/NetworkDeviceDiscoveryScanService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceLabelRuleEngineService.ts

@@ -0,0 +1,204 @@
+import Label from "../../Models/DatabaseModels/Label";
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
+import NetworkDeviceLabelRule from "../../Models/DatabaseModels/NetworkDeviceLabelRule";
+import NetworkDeviceLabelRuleService from "./NetworkDeviceLabelRuleService";
+import NetworkDeviceService from "./NetworkDeviceService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class NetworkDeviceLabelRuleEngineServiceClass {
+  /**
+   * Evaluates NetworkDeviceLabelRule rows for the given network device and attaches matched
+   * labels to it. The union is deduped against labels already on the network device
+   * before insert to avoid PK conflicts on the join table.
+   */
+  @CaptureSpan()
+  public async applyRulesToNetworkDevice(
+    networkDevice: NetworkDevice,
+  ): Promise<void> {
+    if (!networkDevice.id || !networkDevice.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<NetworkDeviceLabelRule> =
+        await NetworkDeviceLabelRuleService.findBy({
+          query: {
+            projectId: networkDevice.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            networkDeviceLabels: { _id: true },
+            networkDeviceNamePattern: true,
+            networkDeviceDescriptionPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const networkDeviceWithDetails: NetworkDevice | null =
+        await NetworkDeviceService.findOneById({
+          id: networkDevice.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!networkDeviceWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesNetworkDeviceMatchRule(
+          networkDeviceWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        for (const label of rule.labelsToAdd || []) {
+          if (label.id) {
+            labelIdsToAdd.add(label.id.toString());
+          }
+        }
+      }
+
+      if (labelIdsToAdd.size === 0) {
+        return;
+      }
+
+      const existingLabelIds: Set<string> = new Set(
+        (networkDeviceWithDetails.labels || [])
+          .map((l: Label) => {
+            return l.id?.toString() || "";
+          })
+          .filter((id: string) => {
+            return id !== "";
+          }),
+      );
+
+      const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
+        (id: string) => {
+          return !existingLabelIds.has(id);
+        },
+      );
+      if (newLabelIds.length === 0) {
+        return;
+      }
+
+      await NetworkDeviceService.getRepository()
+        .createQueryBuilder()
+        .relation(NetworkDevice, "labels")
+        .of(networkDevice.id.toString())
+        .add(newLabelIds);
+
+      /*
+       * Sync in-memory networkDevice.labels so a downstream owner-rule engine in
+       * the same onCreateSuccess chain can match on rule-added labels.
+       */
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      networkDevice.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
+      logger.debug(
+        `NetworkDeviceLabelRuleEngine attached ${newLabelIds.length} labels to network device ${networkDevice.id}`,
+        { projectId: networkDevice.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying network device label rules: ${error}`, {
+        projectId: networkDevice.projectId?.toString(),
+        networkDeviceId: networkDevice.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesNetworkDeviceMatchRule(
+    networkDevice: NetworkDevice,
+    rule: NetworkDeviceLabelRule,
+  ): boolean {
+    if (rule.networkDeviceLabels && rule.networkDeviceLabels.length > 0) {
+      if (!networkDevice.labels || networkDevice.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.networkDeviceLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = networkDevice.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.networkDeviceNamePattern &&
+      (!networkDevice.name ||
+        !this.testRegex(
+          rule.networkDeviceNamePattern,
+          networkDevice.name,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.networkDeviceDescriptionPattern &&
+      (!networkDevice.description ||
+        !this.testRegex(
+          rule.networkDeviceDescriptionPattern,
+          networkDevice.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: NetworkDeviceLabelRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in network device label rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new NetworkDeviceLabelRuleEngineServiceClass();

package/Server/Services/NetworkDeviceLabelRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceLabelRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceOwnerRuleEngineService.ts

@@ -0,0 +1,222 @@
+import Label from "../../Models/DatabaseModels/Label";
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
+import NetworkDeviceOwnerRule from "../../Models/DatabaseModels/NetworkDeviceOwnerRule";
+import NetworkDeviceOwnerUser from "../../Models/DatabaseModels/NetworkDeviceOwnerUser";
+import NetworkDeviceOwnerTeam from "../../Models/DatabaseModels/NetworkDeviceOwnerTeam";
+import NetworkDeviceOwnerRuleService from "./NetworkDeviceOwnerRuleService";
+import NetworkDeviceOwnerUserService from "./NetworkDeviceOwnerUserService";
+import NetworkDeviceOwnerTeamService from "./NetworkDeviceOwnerTeamService";
+import NetworkDeviceService from "./NetworkDeviceService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class NetworkDeviceOwnerRuleEngineServiceClass {
+  /**
+   * Evaluates NetworkDeviceOwnerRule rows for the given network device and adds matched
+   * owner users / teams via NetworkDeviceOwnerUserService / NetworkDeviceOwnerTeamService. Rules
+   * with notifyOwners set notify the added owners; rules with notifyOwners off
+   * add silently.
+   */
+  @CaptureSpan()
+  public async applyRulesToNetworkDevice(
+    networkDevice: NetworkDevice,
+  ): Promise<void> {
+    if (!networkDevice.id || !networkDevice.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<NetworkDeviceOwnerRule> =
+        await NetworkDeviceOwnerRuleService.findBy({
+          query: {
+            projectId: networkDevice.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            notifyOwners: true,
+            networkDeviceLabels: { _id: true },
+            networkDeviceNamePattern: true,
+            networkDeviceDescriptionPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const networkDeviceWithDetails: NetworkDevice | null =
+        await NetworkDeviceService.findOneById({
+          id: networkDevice.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!networkDeviceWithDetails) {
+        return;
+      }
+
+      const usersByNotify: Map<boolean, Set<string>> = new Map([
+        [true, new Set()],
+        [false, new Set()],
+      ]);
+      const teamsByNotify: Map<boolean, Set<string>> = new Map([
+        [true, new Set()],
+        [false, new Set()],
+      ]);
+
+      const matchedRules: Array<NetworkDeviceOwnerRule> = [];
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesNetworkDeviceMatchRule(
+          networkDeviceWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        let ruleAddedAny: boolean = false;
+        const notify: boolean = rule.notifyOwners !== false;
+        for (const user of rule.ownerUsers || []) {
+          if (user.id) {
+            usersByNotify.get(notify)!.add(user.id.toString());
+            ruleAddedAny = true;
+          }
+        }
+        for (const team of rule.ownerTeams || []) {
+          if (team.id) {
+            teamsByNotify.get(notify)!.add(team.id.toString());
+            ruleAddedAny = true;
+          }
+        }
+        if (ruleAddedAny) {
+          matchedRules.push(rule);
+        }
+      }
+
+      if (matchedRules.length === 0) {
+        return;
+      }
+
+      for (const notify of [true, false]) {
+        const userIds: Set<string> = usersByNotify.get(notify)!;
+        const teamIds: Set<string> = teamsByNotify.get(notify)!;
+
+        for (const userId of userIds) {
+          const owner: NetworkDeviceOwnerUser = new NetworkDeviceOwnerUser();
+          owner.networkDeviceId = networkDevice.id;
+          owner.projectId = networkDevice.projectId;
+          owner.userId = new ObjectID(userId);
+          owner.isOwnerNotified = !notify;
+          await NetworkDeviceOwnerUserService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+
+        for (const teamId of teamIds) {
+          const owner: NetworkDeviceOwnerTeam = new NetworkDeviceOwnerTeam();
+          owner.networkDeviceId = networkDevice.id;
+          owner.projectId = networkDevice.projectId;
+          owner.teamId = new ObjectID(teamId);
+          owner.isOwnerNotified = !notify;
+          await NetworkDeviceOwnerTeamService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+      }
+
+      logger.debug(
+        `NetworkDeviceOwnerRuleEngine added owners to network device ${networkDevice.id}`,
+        { projectId: networkDevice.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying network device owner rules: ${error}`, {
+        projectId: networkDevice.projectId?.toString(),
+        networkDeviceId: networkDevice.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesNetworkDeviceMatchRule(
+    networkDevice: NetworkDevice,
+    rule: NetworkDeviceOwnerRule,
+  ): boolean {
+    if (rule.networkDeviceLabels && rule.networkDeviceLabels.length > 0) {
+      if (!networkDevice.labels || networkDevice.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.networkDeviceLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = networkDevice.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.networkDeviceNamePattern &&
+      (!networkDevice.name ||
+        !this.testRegex(
+          rule.networkDeviceNamePattern,
+          networkDevice.name,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.networkDeviceDescriptionPattern &&
+      (!networkDevice.description ||
+        !this.testRegex(
+          rule.networkDeviceDescriptionPattern,
+          networkDevice.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: NetworkDeviceOwnerRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in network device owner rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new NetworkDeviceOwnerRuleEngineServiceClass();

package/Server/Services/NetworkDeviceOwnerRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceOwnerRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceOwnerTeamService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceOwnerTeam";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceOwnerUserService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceOwnerUser";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceService.ts

@@ -0,0 +1,50 @@
+import DatabaseService from "./DatabaseService";
+import NetworkDeviceLabelRuleEngineService from "./NetworkDeviceLabelRuleEngineService";
+import NetworkDeviceOwnerRuleEngineService from "./NetworkDeviceOwnerRuleEngineService";
+import Model from "../../Models/DatabaseModels/NetworkDevice";
+import { OnCreate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Owner/label rules fire whenever a device is created — manually or via
+   * subnet discovery import. Applied out-of-band: rule failures must never
+   * fail device creation.
+   */
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (createdItem.projectId && createdItem.id) {
+      Promise.resolve()
+        .then(async () => {
+          await NetworkDeviceLabelRuleEngineService.applyRulesToNetworkDevice(
+            createdItem,
+          );
+        })
+        .then(async () => {
+          await NetworkDeviceOwnerRuleEngineService.applyRulesToNetworkDevice(
+            createdItem,
+          );
+        })
+        .catch((error: Error) => {
+          logger.error(
+            `Error applying network device rules in NetworkDeviceService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              networkDeviceId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        });
+    }
+    return createdItem;
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkInterfaceService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkInterface";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/TelemetryEntityRelationshipService.ts

@@ -6,6 +6,7 @@ import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { EntityRelationshipEdge } from "../../Utils/Telemetry/EntityRelationship";
 import { reconcileByNaturalKey } from "../Utils/Telemetry/EntityRegistry";
+import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
 
 export class TelemetryEntityRelationshipService extends DatabaseService<Model> {
   public constructor() {
@@ -62,8 +63,30 @@ export class TelemetryEntityRelationshipService extends DatabaseService<Model> {
         model.relationshipType = edge.relationshipType;
         model.firstSeenAt = now;
         model.lastSeenAt = now;
+        if (edge.metrics) {
+          model.callCount = edge.metrics.callCount;
+          model.errorCount = edge.metrics.errorCount;
+          model.avgDurationMs = edge.metrics.avgDurationMs;
+        }
         return model;
       },
+      /*
+       * Metrics describe the latest window only, so each bump replaces
+       * them wholesale. Metric-less edges (co-occurrence) keep whatever
+       * is stored — always null for them. Cast like the scaffold's own
+       * buildBump: checking the literal against the unresolved mapped
+       * type trips TS2589 on this model.
+       */
+      buildUpdate: (): QueryDeepPartialEntity<Model> => {
+        if (!edge.metrics) {
+          return {} as QueryDeepPartialEntity<Model>;
+        }
+        return {
+          callCount: edge.metrics.callCount,
+          errorCount: edge.metrics.errorCount,
+          avgDurationMs: edge.metrics.avgDurationMs,
+        } as unknown as QueryDeepPartialEntity<Model>;
+      },
     });
   }
 }