@oneuptime/common 11.7.3 → 12.0.0

package/Server/Services/LogDropFilterService.ts

@@ -1,10 +1,143 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/LogDropFilter";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import PartialEntity from "../../Types/Database/PartialEntity";
+import {
+  DropFilterCandidate,
+  DropFilterValidationOptions,
+  isSqlExpressionValue,
+  validateDropFilter,
+} from "../Utils/DropFilterValidation";
+
+const VALIDATION_OPTIONS: DropFilterValidationOptions = {
+  recordNoun: "logs",
+};
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    validateDropFilter(
+      {
+        action: createBy.data.action,
+        samplePercentage: createBy.data.samplePercentage,
+        filterQuery: createBy.data.filterQuery as string | undefined,
+      },
+      VALIDATION_OPTIONS,
+    );
+
+    return { createBy, carryForward: null };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    /*
+     * An update can make a row invalid without naming every field: flipping
+     * `action` to "sample" while the stored `samplePercentage` is null, or
+     * blanking `filterQuery` on a row whose action is already "drop". So
+     * validate the MERGED row, not the incoming partial.
+     *
+     * Only pay for the SELECT when the update actually touches one of the
+     * three fields that can break the row. Drop-filter edits are rare,
+     * human-driven config changes — this is not a hot path.
+     */
+    const incomingAction: unknown = updateBy.data.action;
+    const incomingSamplePercentage: unknown = updateBy.data.samplePercentage;
+    const incomingFilterQuery: unknown = updateBy.data.filterQuery;
+
+    const touchesValidatedFields: boolean =
+      incomingAction !== undefined ||
+      incomingSamplePercentage !== undefined ||
+      incomingFilterQuery !== undefined;
+
+    if (!touchesValidatedFields) {
+      return { updateBy, carryForward: null };
+    }
+
+    if (
+      isSqlExpressionValue(incomingAction) ||
+      isSqlExpressionValue(incomingSamplePercentage) ||
+      isSqlExpressionValue(incomingFilterQuery)
+    ) {
+      // Cannot evaluate a raw SQL expression here. See isSqlExpressionValue.
+      return { updateBy, carryForward: null };
+    }
+
+    const existingRows: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      skip: 0,
+      limit: LIMIT_MAX,
+      select: {
+        _id: true,
+        action: true,
+        samplePercentage: true,
+        filterQuery: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const existing of existingRows) {
+      const merged: DropFilterCandidate = {
+        action:
+          incomingAction !== undefined
+            ? (incomingAction as string | null)
+            : existing.action,
+        samplePercentage:
+          incomingSamplePercentage !== undefined
+            ? (incomingSamplePercentage as number | null)
+            : existing.samplePercentage,
+        filterQuery:
+          incomingFilterQuery !== undefined
+            ? (incomingFilterQuery as string | null)
+            : (existing.filterQuery as string | null),
+      };
+
+      validateDropFilter(merged, VALIDATION_OPTIONS);
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  /*
+   * Ingest-path counter flush: add `count` drops to this filter's running
+   * total and stamp `lastDroppedAt`, in one atomic statement.
+   *
+   * Called from the telemetry ingest workers on a throttle (many dropped
+   * log records batched into one UPDATE), never once per record, and never
+   * on the request path. Runs no hooks and does not bump `version`, so it
+   * cannot conflict with a human editing the same filter in the dashboard.
+   *
+   * See App/FeatureSet/Telemetry/Utils/DropFilterDropRecorder.ts.
+   */
+  public async addToDroppedCount(data: {
+    id: ObjectID;
+    count: number;
+    lastDroppedAt?: Date | undefined;
+  }): Promise<void> {
+    if (!data.count || data.count <= 0) {
+      return;
+    }
+
+    await this.atomicAddToColumnsByIdWithoutHooks({
+      id: data.id,
+      add: { droppedCount: data.count },
+      set: {
+        lastDroppedAt: data.lastDroppedAt || OneUptimeDate.getCurrentDate(),
+      } as PartialEntity<Model>,
+    });
+  }
 }
 
 export default new Service();

package/Server/Services/MonitorProbeService.ts

@@ -1,6 +1,7 @@
 import ObjectID from "../../Types/ObjectID";
 import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService, { EntityManager } from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -9,6 +10,7 @@ import Monitor from "../../Models/DatabaseModels/Monitor";
 import QueryHelper from "../Types/Database/QueryHelper";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import MonitorService from "./MonitorService";
+import ProbeService from "./ProbeService";
 import { MonitorTypeHelper } from "../../Types/Monitor/MonitorType";
 import CronTab from "../Utils/CronTab";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -270,6 +272,31 @@ export class Service extends DatabaseService<MonitorProbe> {
       }
     }
 
+    /*
+     * The probe id on a create comes straight from the browser (the
+     * Monitor > Probes table posts it), so it has to be checked against the
+     * tenant exactly like the monitor-create path does - otherwise another
+     * project's probe can be attached to this monitor.
+     */
+    const probeId: ObjectID | undefined | null =
+      createBy.data.probeId || createBy.data.probe?.id;
+    const projectId: ObjectID | undefined | null =
+      createBy.data.projectId || createBy.data.project?.id;
+
+    if (probeId && projectId) {
+      const isProbeAttachable: boolean =
+        await ProbeService.isProbeAttachableToProject({
+          probeId: probeId,
+          projectId: projectId,
+        });
+
+      if (!isProbeAttachable) {
+        throw new BadDataException(
+          "Probe not found or it does not belong to this project.",
+        );
+      }
+    }
+
     // Check if the monitor type supports probes
     const monitorId: ObjectID | undefined | null =
       createBy.data.monitorId || createBy.data.monitor?.id;
@@ -362,12 +389,75 @@ export class Service extends DatabaseService<MonitorProbe> {
     return onUpdate;
   }
 
+  /*
+   * Removing a probe from a monitor changes the same aggregate that adding one
+   * or toggling isEnabled changes - Monitor.isNoProbeEnabledOnThisMonitor and
+   * isAllProbesDisconnectedFromThisMonitor. Without these hooks, deleting the
+   * last probe left the monitor claiming it was still being watched: no
+   * "Probes Not Enabled" banner and no owner notification, even though nothing
+   * was monitoring it any more.
+   *
+   * The monitorIds have to be read before the delete, because after it the
+   * rows are gone.
+   */
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<MonitorProbe>,
+  ): Promise<OnDelete<MonitorProbe>> {
+    const itemsToDelete: Array<MonitorProbe> = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      select: {
+        monitorId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return {
+      deleteBy,
+      carryForward: {
+        monitorIds: itemsToDelete
+          .map((item: MonitorProbe) => {
+            return item.monitorId;
+          })
+          .filter((monitorId: ObjectID | undefined) => {
+            return Boolean(monitorId);
+          }) as Array<ObjectID>,
+      },
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<MonitorProbe>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<MonitorProbe>> {
+    const monitorIds: Array<ObjectID> =
+      (onDelete.carryForward?.monitorIds as Array<ObjectID>) || [];
+
+    const refreshedMonitorIds: Set<string> = new Set();
+
+    for (const monitorId of monitorIds) {
+      // A bulk delete can touch the same monitor many times over.
+      if (refreshedMonitorIds.has(monitorId.toString())) {
+        continue;
+      }
+
+      refreshedMonitorIds.add(monitorId.toString());
+
+      await this.refreshMonitorStatusSafely(monitorId);
+    }
+
+    return onDelete;
+  }
+
   /*
    * Refresh a single monitor's aggregate probe status without letting a
    * failure bubble up. These refreshes run in post-commit hooks
-   * (onCreateSuccess / onUpdateSuccess) after the MonitorProbe row is already
-   * persisted, so a status-refresh error must not turn a successful save into
-   * a 500 for the user — log it instead.
+   * (onCreateSuccess / onUpdateSuccess / onDeleteSuccess) after the
+   * MonitorProbe row is already persisted, so a status-refresh error must not
+   * turn a successful save into a 500 for the user — log it instead.
    */
   private async refreshMonitorStatusSafely(monitorId: ObjectID): Promise<void> {
     try {

package/Server/Services/MonitorService.ts

@@ -70,6 +70,9 @@ import WorkspaceNotificationRuleService, {
   MessageBlocksByWorkspaceType,
 } from "./WorkspaceNotificationRuleService";
 import MonitorStepsProjectValidator from "../Utils/Monitor/MonitorStepsProjectValidator";
+import ProjectScopedReferenceValidator, {
+  resolveReferenceId,
+} from "../Utils/Database/ProjectScopedReferenceValidator";
 import MonitorWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/Monitor";
 import MonitorFeedService from "./MonitorFeedService";
 import { MonitorFeedEventType } from "../../Models/DatabaseModels/MonitorFeed";
@@ -388,7 +391,19 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
-    if (updateBy.data.monitorSteps) {
+    /*
+     * currentMonitorStatusId is writable by any project member and its FK is
+     * ON DELETE NO ACTION, so an id from another project here leaves that
+     * project undeletable — the same shape monitorSteps had. The
+     * 1785240000000 migration repaired the rows that existed then; this stops
+     * new ones. It stays NO ACTION on purpose: deleting a status monitors are
+     * currently in should be blocked, not cascaded.
+     */
+    const currentMonitorStatusId: ObjectID | string | undefined =
+      resolveReferenceId(updateBy.data.currentMonitorStatusId) ||
+      resolveReferenceId(updateBy.data.currentMonitorStatus);
+
+    if (updateBy.data.monitorSteps || currentMonitorStatusId) {
       /*
        * Root/API updates do not always carry a tenantId, so fall back to the
        * project of each monitor the query actually matches.
@@ -398,10 +413,30 @@ export class Service extends DatabaseService<Model> {
         : await this.getProjectIdsForUpdateQuery(updateBy);
 
       for (const projectId of projectIds) {
-        await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
-          monitorSteps: updateBy.data.monitorSteps as MonitorSteps | JSONObject,
-          projectId: projectId,
-        });
+        if (updateBy.data.monitorSteps) {
+          await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject(
+            {
+              monitorSteps: updateBy.data.monitorSteps as
+                | MonitorSteps
+                | JSONObject,
+              projectId: projectId,
+            },
+          );
+        }
+
+        await ProjectScopedReferenceValidator.validateReferencesBelongToProject(
+          {
+            projectId: projectId,
+            subject: "monitor",
+            references: [
+              {
+                modelName: "Monitor Status",
+                id: currentMonitorStatusId,
+                service: MonitorStatusService,
+              },
+            ],
+          },
+        );
       }
     }
 
@@ -660,6 +695,26 @@ export class Service extends DatabaseService<Model> {
       projectId: createBy.props.tenantId,
     });
 
+    /*
+     * A new monitor starts in the project's operational status. A project can
+     * hold MORE than one operational state (a user - or an E2E fixture - can
+     * add another `isOperationalState: true` status), so this lookup MUST be
+     * deterministic. Without an explicit sort, findOneBy falls back to
+     * `createdAt DESC` and hands back whichever operational status was created
+     * most recently - so a monitor created right after a caller adds a custom
+     * operational status silently adopts THAT status as its currentMonitorStatusId
+     * instead of the project's default. When the custom status is later deleted
+     * while the monitor still points at it, the currentMonitorStatusId foreign
+     * key (ON DELETE NO ACTION) blocks the delete forever - the intermittent
+     * "Monitor records still reference it" failure in the Terraform E2E suite,
+     * where the monitors quietly latched onto the fixture's freshly-created
+     * "TF Operational" instead of the seeded default.
+     *
+     * Order by priority ascending (the seeded default operational status is
+     * priority 0 - the primary/highest-precedence operational state) and break
+     * ties by the oldest row, so the choice is stable and always resolves to the
+     * project's canonical operational status.
+     */
     const monitorStatus: MonitorStatus | null =
       await MonitorStatusService.findOneBy({
         query: {
@@ -669,6 +724,10 @@ export class Service extends DatabaseService<Model> {
         select: {
           _id: true,
         },
+        sort: {
+          priority: SortOrder.Ascending,
+          createdAt: SortOrder.Ascending,
+        },
         props: {
           isRoot: true,
         },
@@ -1207,7 +1266,8 @@ ${createdItem.description?.trim() || "No description provided."}
   /*
    * Only global probes and probes belonging to this project may be attached -
    * the id list comes from the browser, so it cannot be trusted to stay inside
-   * the tenant.
+   * the tenant. ProbeService.getProbesAttachableToProject owns that rule and
+   * MonitorProbeService enforces the same one on the CRUD path.
    */
   @CaptureSpan()
   public async addSelectedProbesToMonitor(
@@ -1215,47 +1275,16 @@ ${createdItem.description?.trim() || "No description provided."}
     monitorId: ObjectID,
     probeIds: Array<ObjectID>,
   ): Promise<void> {
-    if (probeIds.length === 0) {
-      return;
-    }
-
-    const [globalProbes, projectProbes]: [Array<Probe>, Array<Probe>] =
-      await Promise.all([
-        ProbeService.findBy({
-          query: {
-            _id: QueryHelper.any(probeIds),
-            isGlobalProbe: true,
-          },
-          select: {
-            _id: true,
-          },
-          skip: 0,
-          limit: LIMIT_PER_PROJECT,
-          props: {
-            isRoot: true,
-          },
-        }),
-        ProbeService.findBy({
-          query: {
-            _id: QueryHelper.any(probeIds),
-            isGlobalProbe: false,
-            projectId: projectId,
-          },
-          select: {
-            _id: true,
-          },
-          skip: 0,
-          limit: LIMIT_PER_PROJECT,
-          props: {
-            isRoot: true,
-          },
-        }),
-      ]);
+    const probes: Array<Probe> =
+      await ProbeService.getProbesAttachableToProject({
+        probeIds: probeIds,
+        projectId: projectId,
+      });
 
     await this.createMonitorProbes({
       projectId: projectId,
       monitorId: monitorId,
-      probes: [...globalProbes, ...projectProbes],
+      probes: probes,
     });
   }
 

package/Server/Services/MonitorStatusService.ts

@@ -1,3 +1,4 @@
+import logger from "../Utils/Logger";
 import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
@@ -142,17 +143,30 @@ export class Service extends DatabaseService<Model> {
         newPriority = monitorStatus.priority! - 1;
       }
 
-      await this.updateOneBy({
-        query: {
-          _id: monitorStatus._id!,
-        },
-        data: {
-          priority: newPriority,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
+      /*
+       * Concurrent deletes (e.g. Terraform destroying several statuses in
+       * parallel) can soft-delete a status between the findBy above and this
+       * update. save() then treats the row as new and INSERTs with a null
+       * projectId, failing the whole delete with a 500. A status that
+       * vanished mid-rearrange needs no repositioning — skip it.
+       */
+      try {
+        await this.updateOneBy({
+          query: {
+            _id: monitorStatus._id!,
+          },
+          data: {
+            priority: newPriority,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      } catch (err) {
+        logger.warn(
+          `rearrangePriority: skipping monitor status ${monitorStatus._id?.toString()} (likely deleted concurrently): ${err}`,
+        );
+      }
     }
   }
 }

package/Server/Services/NetworkDeviceDiscoveryScanService.ts

@@ -1,10 +1,80 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ScanTargetUtil from "../../Utils/NetworkDiscovery/ScanTargetUtil";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * Validate the scan target at write time, with the same parser the probe
+   * expands it with (Common/Utils/NetworkDiscovery/ScanTargetUtil).
+   *
+   * Without this, a typo'd target is accepted, sits Pending until a probe
+   * claims it, and only surfaces minutes later as a Failed scan with the
+   * parser's complaint buried in statusMessage. Octet-range notation makes
+   * that far likelier than CIDR did — a reversed range ("10.22-16.0.1-20") or
+   * an out-of-range octet is easy to type and impossible to spot by eye — so
+   * the feedback belongs on the form, not on a scan result.
+   *
+   * The size ceiling is checked here too: an oversized target is rejected the
+   * moment it is entered rather than after a probe has been handed a sweep it
+   * refuses to run.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    this.validateScanTarget(createBy.data.cidr);
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * The target column is not user-updatable (its ColumnAccessControl grants no
+   * update permission), but root writers — the probe-ingest endpoints, workers,
+   * migrations — bypass that. Validating any update that carries the column
+   * keeps the invariant true for every writer instead of just the form.
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const dataKeys: Array<string> = Object.keys(updateBy.data || {});
+
+    if (dataKeys.includes("cidr")) {
+      this.validateScanTarget(
+        (updateBy.data as Record<string, unknown>)["cidr"],
+      );
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  /*
+   * The value is passed through UNTOUCHED. It arrives straight from the
+   * request JSON — BaseAPI assigns ShortText columns verbatim, and this hook
+   * runs before the model's type and length checks — so it may be a number,
+   * an object or an array, not just a string. ScanTargetUtil already type-
+   * guards and trims internally; normalizing here (the obvious
+   * `(target || "").trim()`) would instead throw a TypeError on any truthy
+   * non-string and turn an intended 400 into a 500.
+   */
+  private validateScanTarget(target: unknown): void {
+    const validationError: string | null = ScanTargetUtil.getValidationError(
+      target as string,
+    );
+
+    if (validationError) {
+      throw new BadDataException(validationError);
+    }
+  }
 }
 
 export default new Service();

package/Server/Services/NetworkDeviceLabelRuleEngineService.ts

@@ -4,6 +4,7 @@ import NetworkDeviceLabelRule from "../../Models/DatabaseModels/NetworkDeviceLab
 import NetworkDeviceLabelRuleService from "./NetworkDeviceLabelRuleService";
 import NetworkDeviceService from "./NetworkDeviceService";
 import ObjectID from "../../Types/ObjectID";
+import RulePatternMatchUtil from "../../Utils/Rules/RulePatternMatchUtil";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 
@@ -159,24 +160,18 @@ class NetworkDeviceLabelRuleEngineServiceClass {
 
     if (
       rule.networkDeviceNamePattern &&
-      (!networkDevice.name ||
-        !this.testRegex(
-          rule.networkDeviceNamePattern,
-          networkDevice.name,
-          rule,
-        ))
+      !this.testPattern(rule.networkDeviceNamePattern, networkDevice.name, rule)
     ) {
       return false;
     }
 
     if (
       rule.networkDeviceDescriptionPattern &&
-      (!networkDevice.description ||
-        !this.testRegex(
-          rule.networkDeviceDescriptionPattern,
-          networkDevice.description,
-          rule,
-        ))
+      !this.testPattern(
+        rule.networkDeviceDescriptionPattern,
+        networkDevice.description,
+        rule,
+      )
     ) {
       return false;
     }
@@ -184,20 +179,24 @@ class NetworkDeviceLabelRuleEngineServiceClass {
     return true;
   }
 
-  private testRegex(
+  /*
+   * Patterns are regexes, with a '*' wildcard fallback so the glob syntax the
+   * neighbouring site assignment rules use does not silently match nothing.
+   * See Common/Utils/Rules/RulePatternMatchUtil.
+   */
+  private testPattern(
     pattern: string,
-    value: string,
+    value: string | undefined,
     rule: NetworkDeviceLabelRule,
   ): boolean {
-    try {
-      const regex: RegExp = new RegExp(pattern, "i");
-      return regex.test(value);
-    } catch {
+    if (!RulePatternMatchUtil.isSupportedPattern(pattern)) {
       logger.warn(
-        `Invalid regex in network device label rule ${rule.id}: ${pattern}`,
+        `Invalid pattern in network device label rule ${rule.id}: ${pattern}. It is neither a valid regular expression nor a wildcard pattern, so it will never match.`,
       );
       return false;
     }
+
+    return RulePatternMatchUtil.matches(value, pattern);
   }
 }
 

package/Server/Services/NetworkDeviceLabelRuleService.ts

@@ -1,6 +1,11 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/NetworkDeviceLabelRule";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import NetworkDeviceRulePatternValidator from "../Utils/NetworkDevice/RulePatternValidator";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -9,6 +14,40 @@ export class Service extends DatabaseService<Model> {
       this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
     }
   }
+
+  /*
+   * A pattern that is neither a valid regex nor a wildcard can only ever
+   * match nothing, and the rule engine has no way to say so - it just quietly
+   * stops labelling. Reject it while the user is still looking at the form.
+   * See Common/Utils/Rules/RulePatternMatchUtil for the accepted syntaxes.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    NetworkDeviceRulePatternValidator.validate({
+      namePattern: createBy.data.networkDeviceNamePattern,
+      descriptionPattern: createBy.data.networkDeviceDescriptionPattern,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    NetworkDeviceRulePatternValidator.validate({
+      namePattern: (updateBy.data as any)["networkDeviceNamePattern"] as
+        | string
+        | undefined,
+      descriptionPattern: (updateBy.data as any)[
+        "networkDeviceDescriptionPattern"
+      ] as string | undefined,
+    });
+
+    return { updateBy, carryForward: null };
+  }
 }
 
 export default new Service();