@oneuptime/common 12.0.32 → 12.0.33

package/Utils/NetworkDiscovery/DiscoveredDeviceBuilder.ts

@@ -5,7 +5,10 @@ import ObjectID from "../../Types/ObjectID";
 import SnmpScanConfigUtil, {
   DiscoveryScanSnmpConfig,
 } from "./SnmpScanConfigUtil";
-import { monitoringMethodForDiscoveredHost } from "./DiscoveryImportEligibility";
+import {
+  isPingOnlyDiscoveredHost,
+  monitoringMethodForDiscoveredHost,
+} from "./DiscoveryImportEligibility";
 import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
 
 /*
@@ -167,7 +170,8 @@ export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
 }
 
 /*
- * The scan columns the builder copies onto an SNMP device. The
+ * The scan columns the builder copies onto a device: the probe onto every
+ * device, the credentials onto the ones that answered SNMP. The
  * NetworkDeviceDiscoveryScan model satisfies this structurally, so both the
  * dashboard (holding a scan model) and the rule engine (holding a scan row it
  * selected itself) can pass their scan straight in.
@@ -177,7 +181,7 @@ export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
  * (and are still mirrored from the list's first entry). Neither is read
  * directly here — SnmpScanConfigUtil reconciles the two — but BOTH have to be
  * SELECTED by every caller, or the credentials silently arrive undefined and
- * the device is created unable to poll. That is what
+ * the device is created as a ping-only one. That is what
  * Common/Tests/Server/Services/AutoImportScanCredentialSelect.test.ts pins.
  */
 export interface DiscoveredDeviceScanSource {
@@ -197,11 +201,18 @@ export interface DiscoveredDeviceScanSource {
 /**
  * The NetworkDevice a discovered host imports as.
  *
- * An SNMP-reachable host becomes a polled device carrying the scan's probe
- * and credentials. A ping-only host becomes a monitor-backed device with no
- * probe, no credentials and polling off: it is recorded so it can belong to a
- * site and appear on the topology map, and binding a monitor to it stays a
- * separate, deliberate step.
+ * Every host becomes a Probe device polled by the scan's probe — the probe
+ * that just proved the host answers, so the one that can keep asking. An
+ * SNMP-reachable host also carries the credential set that answered it, so
+ * its first poll walks it for interfaces, inventory and health. A ping-only
+ * host carries no credentials at all: the probe pings it and nothing more, it
+ * has a status from its first poll, and adding credentials later on its
+ * Settings page is what turns the walk on.
+ *
+ * (It used to import as a monitor-backed device with no probe and polling
+ * off, which left it on "Pending" until an operator hand-bound a Ping monitor
+ * — issue #3447. Reachability is a built-in capability of every probe-polled
+ * device now, so that dead end is gone.)
  *
  * The caller supplies the name (normally `buildDeviceName(host)`) so the
  * name-collision retry can rebuild the same device under
@@ -263,12 +274,41 @@ export function buildNetworkDeviceFromDiscoveredHost(data: {
     monitoringMethodForDiscoveredHost(host);
   device.monitoringMethod = monitoringMethod;
 
-  if (monitoringMethod === NetworkDeviceMonitoringMethod.Monitor) {
+  /*
+   * The scan's probe, on EVERY device. It is the probe that just reached this
+   * host — over ping at the very least — so it is the one that can keep
+   * polling it. Written explicitly rather than left to the column default:
+   * a Probe device with no probe is claimed by nothing and never polls, which
+   * is the "Pending forever" the whole change exists to end.
+   */
+  if (data.scan.probeId) {
+    // Re-wrapped: the scan may hold a serialized id rather than an ObjectID.
+    device.probeId = new ObjectID(data.scan.probeId.toString());
+  }
+
+  /*
+   * Polling on, for both kinds of host. The column defaults to true, but this
+   * function is the recipe both import paths share and "the probe polls this
+   * device" is the whole point of it, so the recipe says so itself rather
+   * than trusting a default that a ping-only host used to override to false.
+   */
+  device.isPollingEnabled = true;
+
+  if (isPingOnlyDiscoveredHost(host)) {
     /*
-     * A ping-only host is never SNMP-polled, so the vendor-template
-     * auto-apply (which keys off a polled sysObjectID) stays off too.
+     * A ping-only host carries NO credentials, decided BEFORE any config is
+     * looked up: `snmpConfigId` and `snmpReachable` are two fields of the
+     * same probe-written jsonb row, and nothing enforces that a ping-only row
+     * leaves the first one unset. A device that answered nothing but a ping
+     * must not import carrying a community string it rejected — it would be
+     * walked with it on every poll and read as an SNMP failure rather than
+     * as the credential-less device it is. The probe pings it and nothing
+     * more until credentials are added on its Settings page.
+     *
+     * The OID template and the vendor-template auto-apply stay off too: both
+     * key off SNMP data — a polled sysObjectID, a walked OID list — that
+     * this host did not supply and will not until it has credentials.
      */
-    device.isPollingEnabled = false;
     return device;
   }
 
@@ -280,11 +320,6 @@ export function buildNetworkDeviceFromDiscoveredHost(data: {
     device.autoApplyVendorHealthTemplate = true;
   }
 
-  if (data.scan.probeId) {
-    // Re-wrapped: the scan may hold a serialized id rather than an ObjectID.
-    device.probeId = new ObjectID(data.scan.probeId.toString());
-  }
-
   /*
    * THE credential set that answered this host, not the scan's first one.
    *

package/Utils/NetworkDiscovery/DiscoveryImportEligibility.ts

@@ -4,10 +4,19 @@ import NetworkDeviceMonitoringMethod from "../../Types/NetworkDevice/NetworkDevi
 /*
  * Pure, react-free import rule for discovery scan results.
  *
- * Every host the sweep found alive is importable; what differs is HOW. A host
- * that answered SNMP becomes a polled device with the scan's credentials. A
- * host that answered only ping becomes a monitor-backed device: no probe, no
- * credentials, health supplied later by a monitor the operator binds to it.
+ * Every host the sweep found alive is importable, and every one of them
+ * imports as a probe-polled device: the scan's probe pings it on its schedule,
+ * and walks it over SNMP as well when it has credentials. What differs between
+ * a host that answered SNMP and one that only answered ping is therefore not
+ * HOW it is monitored but WHAT rides along — the SNMP host carries the scan's
+ * credential set that answered it, the ping-only host carries none and is
+ * simply pinged until somebody adds credentials.
+ *
+ * That is a change from the SNMP-first era, when a ping-only host had to
+ * import as a monitor-backed device with no probe and polling off, and read
+ * "Pending" until an operator hand-bound a Ping monitor to it (issue #3447).
+ * Reachability is a built-in capability of every probe-polled device now, so
+ * the ping-only host gets a status from its first poll like any other.
  *
  * Ping-only hosts used to be refused outright, on the reasoning that they
  * would turn up as ARP/FDB endpoints once their switch was monitored. That is
@@ -20,33 +29,56 @@ import NetworkDeviceMonitoringMethod from "../../Types/NetworkDevice/NetworkDevi
  * because the dashboard's Review dialog and the server-side auto-import rule
  * engine both decide "how does this host import" through it, and the two must
  * never disagree: the group a host is shown under in the dialog and the
- * monitoring method a rule imports it with are the same decision.
+ * device a rule imports it as are the same decision.
  */
 
+/**
+ * True when the host answered ping but not SNMP — the "No SNMP" group in the
+ * Review dialog, and the host that imports with no credentials.
+ *
+ * Only an EXPLICIT snmpReachable === false is ping-only: scans stored before
+ * the field existed carry undefined, and every host on those scans answered
+ * SNMP (ping-only sweeps did not exist yet), so legacy rows keep importing
+ * with the scan's credentials.
+ *
+ * Nullish hosts read as NOT ping-only rather than throwing. `discoveredDevices`
+ * is jsonb written verbatim from the probe's payload and the only guard on it
+ * (DiscoveryScanOutcome.getDiscoveredHosts) checks that the VALUE is an array
+ * — never that its elements are objects. A single null element used to take
+ * the whole page down from inside a table cell or a modal body, where a thrown
+ * TypeError has nowhere useful to go. Every other kind of junk element (a
+ * number, a string, {}) already read as an SNMP host; null is simply
+ * consistent with them.
+ */
+export function isPingOnlyDiscoveredHost(
+  host: DiscoveredNetworkDevice | null | undefined,
+): boolean {
+  return host?.snmpReachable === false;
+}
+
 /**
  * Which monitoring method a discovered host should be imported under.
  *
- * Only an EXPLICIT snmpReachable === false means ping-only: scans stored
- * before the field existed carry undefined, and every host on those scans
- * answered SNMP (ping-only sweeps did not exist yet), so legacy rows keep
- * importing as SNMP devices.
+ * Probe, for every host. Under ping-first polling there is no discovered host
+ * a probe cannot monitor: the scan's probe just proved the host answers ping,
+ * and that is all a probe-polled device needs to have a status. SNMP is an
+ * enrichment layered on top when the host answered it, and
+ * `buildNetworkDeviceFromDiscoveredHost` decides that by
+ * `isPingOnlyDiscoveredHost`, not by this function.
+ *
+ * `Monitor` — a bound monitor's status IS the device's status — is an override
+ * an operator chooses on a device's Settings page for gear a probe cannot
+ * reach at all. Discovery never has grounds to choose it: every host it offers
+ * was reached by the probe that found it.
+ *
+ * Kept as a function, with the host as its argument, because it is the one
+ * seam through which the dialog and the rule engine ask the question, and a
+ * future rule that DID need to look at the host would land here.
  */
 export function monitoringMethodForDiscoveredHost(
-  host: DiscoveredNetworkDevice | null | undefined,
+  _host: DiscoveredNetworkDevice | null | undefined,
 ): NetworkDeviceMonitoringMethod {
-  /*
-   * Nullish hosts read as SNMP rather than throwing. `discoveredDevices` is
-   * jsonb written verbatim from the probe's payload and the only guard on it
-   * (DiscoveryScanOutcome.getDiscoveredHosts) checks that the VALUE is an
-   * array — never that its elements are objects. A single null element used
-   * to take the whole page down from inside a table cell or a modal body,
-   * where a thrown TypeError has nowhere useful to go. Every other kind of
-   * junk element (a number, a string, {}) already read as SNMP; null is now
-   * simply consistent with them.
-   */
-  return host?.snmpReachable === false
-    ? NetworkDeviceMonitoringMethod.Monitor
-    : NetworkDeviceMonitoringMethod.Snmp;
+  return NetworkDeviceMonitoringMethod.Probe;
 }
 
 /** True when the discovered host can be imported as a Network Device. */

package/Utils/NetworkDiscovery/PingMonitorBuilder.ts

@@ -93,6 +93,41 @@ export interface BuildPingMonitorData {
   seedIds: MonitorCriteriaSeedIds;
 }
 
+/**
+ * Where a Ping monitor is being built FROM. The sentence it writes into the
+ * monitor's description is the only thing that differs, and it matters: an
+ * operator reading the monitor list months later should be told whether a
+ * scan, a form, or a bulk action put it there.
+ */
+export enum PingMonitorOrigin {
+  // A host that answered a discovery sweep's ping but not its SNMP probe.
+  DiscoveryImport = "DiscoveryImport",
+  // The device create form, with "create a Ping monitor" ticked.
+  DeviceCreateForm = "DeviceCreateForm",
+  // The "Create Ping Monitor" button on a device's Overview or Monitors page.
+  DevicePage = "DevicePage",
+  // The device list's bulk "Create Ping Monitors" action.
+  BulkAction = "BulkAction",
+}
+
+export interface BuildPingMonitorForAddressData {
+  projectId: ObjectID;
+  /*
+   * The device's address as recorded on the device — an IP or a hostname.
+   * NetworkDevice.hostname is free text and required, so this is never empty
+   * for a real device; it is still validated because the bulk action and the
+   * create form both hand over whatever the operator typed.
+   */
+  address: string;
+  /*
+   * The name of the NetworkDevice this monitor will be bound to, so the two
+   * read as a pair in a monitor list that also contains unrelated monitors.
+   */
+  deviceName: string;
+  seedIds: MonitorCriteriaSeedIds;
+  origin: PingMonitorOrigin;
+}
+
 /**
  * The monitor's name: "Ping <device name>", clamped to the column.
  *
@@ -157,24 +192,54 @@ function suppressIncidentCreation(step: MonitorStep): void {
 }
 
 /**
- * One ping-only discovered host -> the Ping monitor that will report its
- * health once bound to the device through `NetworkDevice.monitorId`.
+ * The sentence a provisioned monitor carries so its origin is legible later.
+ * Exported so the surfaces that build one can be tested against the exact
+ * wording rather than a paraphrase.
+ */
+export function buildPingMonitorDescription(data: {
+  address: string;
+  origin: PingMonitorOrigin;
+}): string {
+  const reachability: string = `Reachability for ${data.address}`;
+
+  switch (data.origin) {
+    case PingMonitorOrigin.DiscoveryImport:
+      return `${reachability}, created when this device was imported from a network discovery scan. The device answered ping but not SNMP, so this monitor is what reports whether it is up.`;
+    case PingMonitorOrigin.DeviceCreateForm:
+      return `${reachability}, created with this network device. The device is monitor-backed — nothing polls it over SNMP — so this monitor is what reports whether it is up.`;
+    case PingMonitorOrigin.BulkAction:
+      return `${reachability}, created by the device list's "Create Ping Monitors" action. The device is monitor-backed — nothing polls it over SNMP — so this monitor is what reports whether it is up.`;
+    case PingMonitorOrigin.DevicePage:
+    default:
+      return `${reachability}, created from this network device's page. The device is monitor-backed — nothing polls it over SNMP — so this monitor is what reports whether it is up.`;
+  }
+}
+
+/**
+ * One device address -> the Ping monitor that will report the device's
+ * health once bound to it through `NetworkDevice.monitorId`.
  *
- * The caller creates this monitor FIRST, then creates the device carrying the
- * new monitor's id: `NetworkDeviceService.onCreateSuccess` stamps the
- * monitor's current status onto the device at bind time, so the device's
- * status pill resolves on the first render rather than waiting for the
- * monitor's next status CHANGE (which on a healthy network may never come —
- * that was OneUptime/oneuptime#3392).
+ * This is the shape every provisioning surface shares: discovery import, the
+ * device create form, the "Create Ping Monitor" button on a device's page and
+ * the bulk action on the device list. They differ only in where the address
+ * and the name come from and in the origin sentence; the monitor itself —
+ * type, interval, criteria, incident suppression — is identical, which is
+ * what lets an operator treat every provisioned monitor the same way.
+ *
+ * Order of operations is the caller's: discovery creates the monitor FIRST
+ * and then the device carrying its id (so the create-time stamp resolves the
+ * pill immediately), while the create form and the bulk action create or
+ * already have the device and bind afterwards — which re-stamps through
+ * `NetworkDeviceService.onUpdateSuccess`, so the pill resolves just the same.
  */
-export function buildPingMonitorForDiscoveredHost(
-  data: BuildPingMonitorData,
+export function buildPingMonitorForAddress(
+  data: BuildPingMonitorForAddressData,
 ): Monitor {
-  const address: string = (data.host?.ipAddress || "").trim();
+  const address: string = (data.address || "").trim();
 
   if (!address) {
     throw new Error(
-      "A discovered host needs an address before a Ping monitor can be built for it.",
+      "A device needs an address before a Ping monitor can be built for it.",
     );
   }
 
@@ -182,7 +247,10 @@ export function buildPingMonitorForDiscoveredHost(
 
   monitor.projectId = new ObjectID(data.projectId.toString());
   monitor.name = buildPingMonitorName(data.deviceName);
-  monitor.description = `Reachability for ${address}, created when this device was imported from a network discovery scan. The device answered ping but not SNMP, so this monitor is what reports whether it is up.`;
+  monitor.description = buildPingMonitorDescription({
+    address: address,
+    origin: data.origin,
+  });
   monitor.monitorType = MonitorType.Ping;
   monitor.monitoringInterval = PING_MONITOR_INTERVAL;
 
@@ -213,3 +281,37 @@ export function buildPingMonitorForDiscoveredHost(
 
   return monitor;
 }
+
+/**
+ * One ping-only discovered host -> the Ping monitor that will report its
+ * health once bound to the device through `NetworkDevice.monitorId`.
+ *
+ * The caller creates this monitor FIRST, then creates the device carrying the
+ * new monitor's id: `NetworkDeviceService.onCreateSuccess` stamps the
+ * monitor's current status onto the device at bind time, so the device's
+ * status pill resolves on the first render rather than waiting for the
+ * monitor's next status CHANGE (which on a healthy network may never come —
+ * that was OneUptime/oneuptime#3392).
+ *
+ * A thin adapter over `buildPingMonitorForAddress`: the only thing a
+ * discovered host contributes is its address.
+ */
+export function buildPingMonitorForDiscoveredHost(
+  data: BuildPingMonitorData,
+): Monitor {
+  const address: string = (data.host?.ipAddress || "").trim();
+
+  if (!address) {
+    throw new Error(
+      "A discovered host needs an address before a Ping monitor can be built for it.",
+    );
+  }
+
+  return buildPingMonitorForAddress({
+    projectId: data.projectId,
+    address: address,
+    deviceName: data.deviceName,
+    seedIds: data.seedIds,
+    origin: PingMonitorOrigin.DiscoveryImport,
+  });
+}

package/Utils/NetworkSite/SiteStatusRollupUtil.ts

@@ -1,6 +1,7 @@
 import DeviceReachabilityUtil, {
   NetworkDeviceReachability,
 } from "../NetworkDevice/DeviceReachabilityUtil";
+import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 import SiteHealthRollupPolicy, {
   DefaultSiteOfflineThresholdPercent,
 } from "../../Types/NetworkSite/SiteHealthRollupPolicy";
@@ -25,14 +26,26 @@ import SiteHealthRollupPolicy, {
  *
  * Both policies agree on which devices get a vote at all: a device that has
  * never reported anything is not evidence of an outage and is skipped by
- * each of them.
+ * each of them. And both agree on what a device's vote IS: for a
+ * monitor-backed device the stamped MonitorStatus, for a probe-polled one
+ * the outcome of its last poll — the stamp on a probe-polled device is
+ * informational (see the field docs), the same precedence the device list
+ * pill, the site card and the map apply.
  */
 
 // One device's health inputs, denormalized by the rollup engine.
 export interface DeviceHealthState {
   /*
    * The MonitorStatus stamped by the monitor bridge (string form). When set
-   * together with its priority, it is the device's authoritative status.
+   * together with its priority ON A MONITOR-BACKED DEVICE, it is the
+   * device's authoritative status.
+   *
+   * A probe-polled device can carry one too — a Network Device monitor
+   * watching its walk stamps it, and an "interface down → Offline" criterion
+   * will stamp Offline on a switch that answers every ping. Its health
+   * source is the poll (`isReachable`, which is what its own pill reads), so
+   * the stamp is ignored here for it, or one dark port would turn a site of
+   * answering devices offline while every row under it reads Up.
    */
   currentMonitorStatusId?: string | null | undefined;
   // Priority of that status row; missing when the row no longer exists.
@@ -50,16 +63,32 @@ export interface DeviceHealthState {
    */
   monitorStatusIsOperational?: boolean | null | undefined;
   /*
-   * The SNMP fallback for devices no monitor stamps, resolved by the shared
-   * DeviceReachabilityUtil rule: the OUTCOME of the last poll, not the age
-   * of the last success. Rolling a site up from freshness alone is what
-   * turned "the probe is behind on a 900-device fleet" into a red site card
-   * over devices that were all answering.
+   * The poll verdict for probe-polled devices, resolved by the shared
+   * DeviceReachabilityUtil rule: the OUTCOME of the last poll (ping, or the
+   * SNMP walk), not the age of the last success. Rolling a site up from
+   * freshness alone is what turned "the probe is behind on a 900-device
+   * fleet" into a red site card over devices that were all answering.
    */
   isReachable?: boolean | null | undefined;
   lastPolledAt?: Date | null | undefined;
   lastSeenAt?: Date | null | undefined;
   pollingIntervalInMinutes?: number | null | undefined;
+  /*
+   * How this device's health is established. NULL, empty and anything
+   * unrecognised read as Probe — see NetworkDeviceMonitoringMethodUtil.parse,
+   * which is why an omitted value keeps every existing caller on the poll
+   * rule unchanged.
+   *
+   * Load-bearing twice. It decides whether the stamped status above is the
+   * device's vote at all (only for a monitor-backed device). And a
+   * monitor-backed device (monitoringMethod "Monitor") that has no stamp
+   * yet — or whose stamped row could not be resolved — has poll columns
+   * that mean nothing (NULL, or the last thing a probe found before it
+   * stopped asking). The shared rule reads it as Pending and both policies
+   * skip it, exactly as they skip a never-polled probe device, rather than
+   * letting a months-old lastSeenAt cast a vote against the site.
+   */
+  monitoringMethod?: string | null | undefined;
   /*
    * How many real devices this entry stands for.
    *
@@ -118,13 +147,13 @@ export class SiteStatusRollupUtil {
    * operational/offline rows) - the caller treats null as "leave the site's
    * status untouched".
    *
-   * Per device: a stamped monitor status (with a known priority) wins;
-   * otherwise the device's SNMP reachability maps Up to the project's
-   * isOperationalState row and Down to its isOfflineState row. A device
-   * that has never been polled contributes nothing at all - it is not
-   * evidence of an outage, and counting it as one used to pin a site red
-   * for as long as it took the first walk to land. Priority ties keep the
-   * first contributor (stable).
+   * Per device: on a monitor-backed device a stamped monitor status (with a
+   * known priority) is the vote; otherwise the device's poll reachability
+   * maps Up to the project's isOperationalState row and Down to its
+   * isOfflineState row. A device that has never been polled contributes
+   * nothing at all - it is not evidence of an outage, and counting it as
+   * one used to pin a site red for as long as it took the first poll to
+   * land. Priority ties keep the first contributor (stable).
    */
   public static worstStatus(data: {
     deviceStates: Array<DeviceHealthState>;
@@ -148,6 +177,7 @@ export class SiteStatusRollupUtil {
       let candidate: RollupStatusOption | null = null;
 
       if (
+        SiteStatusRollupUtil.isStampAuthoritative(device) &&
         device.currentMonitorStatusId &&
         typeof device.monitorStatusPriority === "number" &&
         Number.isFinite(device.monitorStatusPriority)
@@ -200,12 +230,12 @@ export class SiteStatusRollupUtil {
    * How the subtree splits between operational and not, in DEVICES rather
    * than in buckets.
    *
-   * A device counts as non-operational when its stamped MonitorStatus is not
-   * the operational one, or - for devices no monitor stamps - when its SNMP
-   * reachability is Down. Never-reported devices are excluded from both the
-   * numerator and the denominator, so a region half-way through its first
-   * discovery walk is scored on the half that has answered rather than
-   * marked down for the half that has not.
+   * A monitor-backed device counts as non-operational when its stamped
+   * MonitorStatus is not the operational one; a probe-polled device when its
+   * poll reachability is Down. Never-reported devices are excluded from both
+   * the numerator and the denominator, so a region half-way through its
+   * first discovery walk is scored on the half that has answered rather
+   * than marked down for the half that has not.
    */
   public static deviceHealthShare(data: {
     deviceStates: Array<DeviceHealthState>;
@@ -238,6 +268,7 @@ export class SiteStatusRollupUtil {
       const count: number = SiteStatusRollupUtil.deviceCountOf(device);
 
       if (
+        SiteStatusRollupUtil.isStampAuthoritative(device) &&
         device.currentMonitorStatusId &&
         typeof device.monitorStatusIsOperational === "boolean"
       ) {
@@ -415,6 +446,19 @@ export class SiteStatusRollupUtil {
     return Math.floor(value);
   }
 
+  /*
+   * Whether this device's stamped MonitorStatus is its vote — true only for
+   * a monitor-backed device. One gate for both policies, so the same fleet
+   * cannot read differently depending on which one a site uses; and the
+   * same gate DeviceHealthStateUtil and the topology map apply, so the site
+   * card, the map and this rollup describe one network.
+   */
+  private static isStampAuthoritative(device: DeviceHealthState): boolean {
+    return NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+      device.monitoringMethod,
+    );
+  }
+
   private static deviceCountOf(device: DeviceHealthState): number {
     if (
       typeof device.deviceCount !== "number" ||
@@ -436,6 +480,8 @@ export class SiteStatusRollupUtil {
         lastPolledAt: device.lastPolledAt,
         lastSeenAt: device.lastSeenAt,
         pollingIntervalInMinutes: device.pollingIntervalInMinutes,
+        // See the field docs: decides whether the columns above mean anything.
+        monitoringMethod: device.monitoringMethod,
       },
       now,
     );