@oneuptime/common 12.0.25 → 12.0.27

package/Models/DatabaseModels/Monitor.ts

@@ -1,6 +1,7 @@
 import Label from "./Label";
 import MonitorStatus from "./MonitorStatus";
 import MonitorTemplate from "./MonitorTemplate";
+import NetworkDevice from "./NetworkDevice";
 import Project from "./Project";
 import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
@@ -91,6 +92,15 @@ import NotificationRuleWorkspaceChannel from "../../Types/Workspace/Notification
 @EnableAuditLog()
 @CrudApiEndpoint(new Route("/monitor"))
 @SlugifyColumn("name", "slug")
+@Index(
+  "IDX_monitor_auto_provisioned_device_template_unique",
+  ["autoProvisionedNetworkDeviceId", "monitorTemplateId"],
+  {
+    unique: true,
+    where:
+      '"deletedAt" IS NULL AND "autoProvisionedNetworkDeviceId" IS NOT NULL AND "monitorTemplateId" IS NOT NULL',
+  },
+)
 @Entity({
   name: "Monitor",
 })
@@ -677,6 +687,83 @@ export default class Monitor extends BaseModel {
   })
   public monitorTemplateId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.MonitorAdmin,
+      Permission.MonitorMember,
+      Permission.MonitorViewer,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "autoProvisionedNetworkDeviceId",
+    type: TableColumnType.Entity,
+    // Lazy: Monitor and NetworkDevice import each other (see modelTypeThunk).
+    modelTypeThunk: () => {
+      return NetworkDevice;
+    },
+    title: "Auto-Provisioned Network Device",
+    description:
+      "Network Device that caused this monitor to be provisioned automatically",
+  })
+  @ManyToOne(
+    () => {
+      return NetworkDevice;
+    },
+    {
+      eager: false,
+      nullable: true,
+      /*
+       * Service deletion removes automatic monitors through MonitorService.
+       * RESTRICT is the final race backstop: a monitor inserted after that
+       * preflight makes the device delete fail instead of being silently
+       * cascade-deleted without authorization or lifecycle hooks.
+       */
+      onDelete: "RESTRICT",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({
+    name: "autoProvisionedNetworkDeviceId",
+    foreignKeyConstraintName: "FK_monitor_auto_provisioned_network_device",
+  })
+  public autoProvisionedNetworkDevice?: NetworkDevice = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.MonitorAdmin,
+      Permission.MonitorMember,
+      Permission.MonitorViewer,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Auto-Provisioned Network Device ID",
+    description:
+      "ID of the Network Device that caused this monitor to be provisioned automatically",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public autoProvisionedNetworkDeviceId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/NetworkDevice.ts

@@ -79,7 +79,68 @@ import {
 })
 @CrudApiEndpoint(new Route("/network-device"))
 @SlugifyColumn("name", "slug")
-@Index(["projectId", "isArchived"])
+/*
+ * Indexes for a fleet of eighty thousand devices in one project. Each one is
+ * here for a query the product runs constantly, and nothing here is
+ * speculative — the columns a poll rewrites every cycle are indexed only
+ * where a sequential scan is the alternative.
+ */
+
+/*
+ * The device list's default page, and every fleet-wide count over it.
+ *
+ * `createdAt` is the third column because the list has no explicit sort and
+ * DatabaseService falls back to `createdAt DESC`: without it, showing the
+ * first ten devices means scanning the whole project and top-N sorting eighty
+ * thousand rows. The two-column prefix still serves every count and filter
+ * that only cares about project and archived-ness, so this replaces the
+ * `(projectId, isArchived)` index rather than joining it — a redundant prefix
+ * index is pure write amplification on a table every poll updates.
+ */
+@Index(["projectId", "isArchived", "createdAt"])
+/*
+ * The Status facet, and the three counts in the summary strip that have to
+ * agree with it. `isReachable` partitions the fleet into up / down / never
+ * polled, and it only changes when a device actually changes state, so it is
+ * cheap to keep sorted.
+ *
+ * `lastSeenAt` rides along as a fourth column for the Overview's "devices
+ * needing attention" list, which asks for the unreachable devices LONGEST out
+ * of contact. Without it the ordering cannot come from the index and every
+ * down device in the project is fetched and top-N sorted to return eight.
+ */
+@Index(["projectId", "isArchived", "isReachable", "lastSeenAt"])
+/*
+ * Every per-site rollup, the hierarchy drill-down, and the "unassigned
+ * devices" count. A device's site almost never changes, so this is close to
+ * free to maintain and the alternative is a full scan per rollup.
+ */
+@Index(["projectId", "siteId"])
+/*
+ * The other half of the Overview's attention list: reachable devices with the
+ * most dark ports.
+ *
+ * PARTIAL, and that is the point — `interfacesDown > 0` is true for a small
+ * minority of a healthy fleet, so the index is a fraction of the table's size
+ * and, more importantly, an interface flap on a device that has none only
+ * touches it when the count crosses zero. A full index on a column every SNMP
+ * walk rewrites would be write amplification on the hottest table in the
+ * product for the sake of one eight-row list.
+ */
+@Index(["projectId", "interfacesDown"], {
+  where: '"interfacesDown" > 0 AND "isArchived" = false',
+})
+/*
+ * The polling claim loop — `claimDevicesForPolling`, which every probe runs
+ * on every cycle: "my devices whose nextPollAt has come, oldest first".
+ *
+ * The foreign key on `probeId` creates no index of its own in Postgres, so
+ * without this each probe scanned the entire NetworkDevice table (every
+ * project's devices, not just its own) several times a minute. `nextPollAt`
+ * IS rewritten by every claim, which is real write cost — and still by far
+ * the cheaper side of the trade at this size.
+ */
+@Index(["probeId", "nextPollAt"])
 /*
  * Restores a UNIQUE index that an autogenerated migration deleted.
  *
@@ -721,7 +782,10 @@ export default class NetworkDevice extends BaseModel {
   @TableColumn({
     manyToOneRelationColumn: "monitorId",
     type: TableColumnType.Entity,
-    modelType: Monitor,
+    // Lazy: Monitor and NetworkDevice import each other (see modelTypeThunk).
+    modelTypeThunk: () => {
+      return Monitor;
+    },
     title: "Monitor",
     description:
       "The monitor that reports this device's health when its monitoring method is Monitor. Any monitor type works — Ping and IP are the usual choices for gear that does not speak SNMP.",
@@ -1488,15 +1552,42 @@ export default class NetworkDevice extends BaseModel {
     ],
   })
   @TableColumn({
-    required: false,
+    /*
+     * The database fills this in, and no caller may supply it (the create
+     * access control below is deliberately empty). Without this flag
+     * `DatabaseService.checkRequiredFields` rejects every create — from the
+     * dashboard form, the CRUD API and the discovery auto-import alike — for a
+     * column nobody is allowed to set. Same pairing as `isPollingEnabled`.
+     */
+    isDefaultValueColumn: true,
+    required: true,
     type: TableColumnType.Date,
     title: "Next Poll At",
     description:
-      "When the assigned probe should next poll this device. Advanced by the claim cycle; NULL means poll as soon as possible.",
+      "When the assigned probe should next poll this device. Advanced by the claim cycle; a device created now is due immediately.",
   })
+  /*
+   * NOT NULL, defaulting to now — and that is a performance decision as much
+   * as a modelling one.
+   *
+   * It used to be nullable, with NULL meaning "poll as soon as possible", so
+   * the claim query had to read `(nextPollAt IS NULL OR nextPollAt <= now)`
+   * ordered `ASC NULLS FIRST`. A btree is ASC NULLS LAST, so that ordering
+   * could not be served by the (probeId, nextPollAt) index no matter what:
+   * every claim cycle sequentially scanned the probe's whole slice of the
+   * fleet and top-N sorted it — 117ms and 2,702 buffers for one probe with
+   * 40,000 devices, measured, once a minute, forever, inside a transaction
+   * already holding FOR UPDATE row locks.
+   *
+   * `now()` says exactly what NULL said — this device is due — in a value the
+   * index can order. The same claim is 0.85ms and 86 buffers.
+   */
   @Column({
-    nullable: true,
+    nullable: false,
     type: ColumnType.Date,
+    default: () => {
+      return "now()";
+    },
   })
   public nextPollAt?: Date = undefined;
 

package/Models/DatabaseModels/NetworkDeviceAutoImportRule.ts

@@ -1,3 +1,4 @@
+import MonitorTemplate from "./MonitorTemplate";
 import Project from "./Project";
 import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
@@ -23,13 +24,13 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
  * manual "Review Results -> Import" step — the OneUptime shape of Zabbix's
  * autoregistration actions (issue #3378).
  *
- * The rule is deliberately a pure CREATION GATE: conditions decide WHICH
- * discovered hosts import, and the import itself goes through the same
- * builder as the manual dialog. Everything downstream of creation — site
- * assignment, owners, labels — already fires automatically from
+ * Conditions decide WHICH discovered hosts import, and the optional monitor
+ * template decides whether each imported SNMP device also gets a Network
+ * Device monitor. Everything else downstream of creation — site assignment,
+ * owners, labels — already fires automatically from
  * NetworkDeviceService.onCreateSuccess through the existing
  * NetworkSiteAssignmentRule / NetworkDeviceOwnerRule / NetworkDeviceLabelRule
- * engines, so this model carries no operation columns to fight them with.
+ * engines, so this model carries no competing operation columns.
  *
  * Conditions on one rule are ANDed; OR is more rules. An exclusion rule
  * (isExclusion) vetoes matching import rules — "never auto-import X".
@@ -76,7 +77,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
   pluralName: "Network Device Auto Import Rules",
   icon: IconProp.Automation,
   tableDescription:
-    "Automatically import matching hosts from network device discovery scan results as Network Devices, with no manual review step",
+    "Automatically import matching hosts from network device discovery scan results as Network Devices and optionally provision a monitor from a template",
 })
 /*
  * The index and foreign-key names below are written out rather than left to
@@ -465,6 +466,91 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
   })
   public isExclusion?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateNetworkDeviceAutoImportRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.MonitorAdmin,
+      Permission.MonitorMember,
+      Permission.MonitorViewer,
+      Permission.ReadMonitorTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditNetworkDeviceAutoImportRule,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "monitorTemplateId",
+    type: TableColumnType.Entity,
+    modelType: MonitorTemplate,
+    title: "Monitor Template",
+    description:
+      "Optional Network Device monitor template to apply to devices imported by this rule",
+  })
+  @ManyToOne(
+    () => {
+      return MonitorTemplate;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({
+    name: "monitorTemplateId",
+    foreignKeyConstraintName: "FK_nd_auto_import_rule_monitorTemplateId",
+  })
+  public monitorTemplate?: MonitorTemplate = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateNetworkDeviceAutoImportRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.MonitorAdmin,
+      Permission.MonitorMember,
+      Permission.MonitorViewer,
+      Permission.ReadMonitorTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditNetworkDeviceAutoImportRule,
+    ],
+  })
+  @Index("IDX_network_device_auto_import_rule_monitorTemplateId")
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Monitor Template ID",
+    description:
+      "ID of the optional Network Device monitor template to apply to devices imported by this rule",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public monitorTemplateId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,