@oneuptime/common 12.0.30 → 12.0.32

package/Utils/Monitor/NetworkTopologyUtil.ts

@@ -1,4 +1,5 @@
 import NetworkTopology, {
+  NetworkTopologyDeviceRole,
   NetworkTopologyEdge,
   NetworkTopologyEdgeEndpoint,
   NetworkTopologyLinkProtocol,
@@ -13,6 +14,13 @@ import {
   classifyEndpointRole,
   resolveDeviceRole,
 } from "./NetworkDeviceRoleUtil";
+import {
+  TopologyDeviceRoleInput,
+  applyRoleStamp,
+  buildDeviceRoleIndex,
+  roleKeyForNode,
+  stampForRoleKey,
+} from "./NetworkDeviceRoleCatalog";
 import DeviceReachabilityUtil, {
   NetworkDeviceReachability,
 } from "../NetworkDevice/DeviceReachabilityUtil";
@@ -45,11 +53,18 @@ export interface TopologyDeviceInput {
   sysDescr?: string | undefined;
   sysObjectId?: string | undefined;
   /*
-   * The operator's own answer to what this device is, when they gave one.
-   * Outranks the classifier below, because it is the only statement about
-   * the role that is not an inference — and on a device nothing walks it
-   * is the ONLY statement available at all, the classifier having nothing
-   * but a hostname to go on.
+   * The KEY of the role the operator assigned this device, when they
+   * assigned one. Outranks the classifier below, because it is the only
+   * statement about the role that is not an inference — and on a device
+   * nothing walks it is the ONLY statement available at all, the classifier
+   * having nothing but a hostname to go on.
+   *
+   * A key, not a name: roles are per-project rows an operator can rename, so
+   * the caller reads it off the assigned row (NetworkDevice.networkDeviceRole)
+   * rather than passing a label. It may be a key outside the built-in twelve
+   * — a role the project invented — in which case `role` on the node falls
+   * back to the classifier and the node's roleKey/roleLabel/roleShape carry
+   * the configured answer instead. See buildTopology's deviceRoles argument.
    */
   deviceRole?: string | undefined;
   /*
@@ -329,9 +344,19 @@ export default class NetworkTopologyUtil {
     endpoints: Array<TopologyEndpointInput> = [],
     manualLinks: Array<TopologyManualLinkInput> = [],
     suppressedNodeKeys: ReadonlySet<string> = new Set<string>(),
+    deviceRoles: ReadonlyArray<TopologyDeviceRoleInput> = [],
   ): TopologyBuildResult {
     const nodes: Array<NetworkTopologyNode> = [];
 
+    /*
+     * The project's configured roles, indexed by key. Passing none is a
+     * supported case - the nodes then carry no role stamp and every consumer
+     * falls back to the built-in labels, shapes and core set, which is exactly
+     * the map drawn before roles were configurable.
+     */
+    const roleIndex: Map<string, TopologyDeviceRoleInput> =
+      buildDeviceRoleIndex(deviceRoles);
+
     /*
      * Index managed devices by every identifier a neighbor entry could
      * reference. A key TWO devices both claim is deleted rather than
@@ -384,26 +409,47 @@ export default class NetworkTopologyUtil {
         device.id,
         device.isNeighborDiscoveryEnabled,
       );
-      nodes.push({
-        id: device.id,
-        name: device.name,
-        isManaged: true,
-        kind: "device",
-        role: resolveDeviceRole(device.deviceRole, {
+      const deviceRole: NetworkTopologyDeviceRole = resolveDeviceRole(
+        device.deviceRole,
+        {
           sysDescr: device.sysDescr,
           sysObjectId: device.sysObjectId,
           vendor: device.vendor,
           deviceModel: device.deviceModel,
           name: device.name,
           sysName: device.sysName || device.hostname,
-        }),
+        },
+      );
+
+      const deviceNode: NetworkTopologyNode = {
+        id: device.id,
+        name: device.name,
+        isManaged: true,
+        kind: "device",
+        role: deviceRole,
         status: NetworkTopologyUtil.deviceStatus(device, now),
         interfacesUp: device.interfacesUp,
         interfacesDown: device.interfacesDown,
         sysName: device.sysName,
         vendor: device.vendor,
         deviceModel: device.deviceModel,
-      });
+      };
+
+      /*
+       * The configured role, when the project has one for this key. The
+       * assignment is looked up ahead of the classifier's answer, so a device
+       * an operator gave a CUSTOM role ("PoS Terminal") is drawn as that role
+       * even though `role` above can only ever be one of the built-in twelve.
+       */
+      applyRoleStamp(
+        deviceNode,
+        stampForRoleKey(
+          roleKeyForNode(device.deviceRole, deviceRole),
+          roleIndex,
+        ),
+      );
+
+      nodes.push(deviceNode);
     }
 
     const edgeByKey: Map<string, NetworkTopologyEdge> = new Map();
@@ -465,7 +511,11 @@ export default class NetworkTopologyUtil {
       NetworkTopologyUtil.propagateMatchesAcrossPeerGroups(resolvedClaims);
 
     const peerNodeIdByClaim: Map<ResolvedClaim, string> =
-      NetworkTopologyUtil.buildUnmanagedPeerNodes(settledClaims, nodes);
+      NetworkTopologyUtil.buildUnmanagedPeerNodes(
+        settledClaims,
+        nodes,
+        roleIndex,
+      );
 
     for (const resolved of settledClaims) {
       const device: TopologyDeviceInput = resolved.device;
@@ -780,16 +830,18 @@ export default class NetworkTopologyUtil {
         endpoint.vendor ||
         endpoint.ipAddress ||
         endpoint.macAddress;
-      nodes.push({
+      const endpointRole: NetworkTopologyDeviceRole = classifyEndpointRole({
+        classification: endpoint.classification,
+        vendor: endpoint.vendor,
+        name: endpointName,
+      });
+
+      const endpointNode: NetworkTopologyNode = {
         id: nodeId,
         name: endpointName,
         isManaged: false,
         kind: "endpoint",
-        role: classifyEndpointRole({
-          classification: endpoint.classification,
-          vendor: endpoint.vendor,
-          name: endpointName,
-        }),
+        role: endpointRole,
         status: NetworkTopologyUtil.statusFromLastSeen(
           endpoint.lastSeenAt,
           now,
@@ -799,7 +851,21 @@ export default class NetworkTopologyUtil {
         ipAddress: endpoint.ipAddress,
         classification: endpoint.classification,
         vlanId: endpoint.vlanId,
-      });
+      };
+
+      /*
+       * Endpoints are stamped too, so a project that renamed "IP phone" sees
+       * the new name on the handsets its switches learned. It cannot change
+       * where they sit: the layouts put every endpoint in its switch's group
+       * box before they ever look at a role, so isCoreLayerRole is inert here
+       * by construction rather than by omission.
+       */
+      applyRoleStamp(
+        endpointNode,
+        stampForRoleKey(roleKeyForNode(undefined, endpointRole), roleIndex),
+      );
+
+      nodes.push(endpointNode);
 
       // Port label + interface state on the switch end, when identifiable.
       let switchInterface: TopologyInterfaceInput | undefined = undefined;
@@ -1264,6 +1330,10 @@ export default class NetworkTopologyUtil {
   private static buildUnmanagedPeerNodes(
     resolvedClaims: Array<ResolvedClaim>,
     nodes: Array<NetworkTopologyNode>,
+    roleIndex: Map<string, TopologyDeviceRoleInput> = new Map<
+      string,
+      TopologyDeviceRoleInput
+    >(),
   ): Map<ResolvedClaim, string> {
     const unmanagedClaims: Array<ResolvedClaim> = resolvedClaims.filter(
       (resolved: ResolvedClaim) => {
@@ -1359,21 +1429,22 @@ export default class NetworkTopologyUtil {
       usedNodeIds.add(nodeId);
 
       const unmanagedName: string = displayName || "Unknown device";
-      nodes.push({
+      /*
+       * Classified from the whole group rather than from whichever
+       * report happened to be first: the platform string is usually the
+       * only real evidence about a peer, and it may well arrive on the
+       * second report of it.
+       */
+      const unmanagedRole: NetworkTopologyDeviceRole = classifyDeviceRole({
+        platform: platform,
+        name: unmanagedName,
+      });
+      const unmanagedNode: NetworkTopologyNode = {
         id: nodeId,
         name: unmanagedName,
         isManaged: false,
         kind: "unmanaged",
-        /*
-         * Classified from the whole group rather than from whichever
-         * report happened to be first: the platform string is usually the
-         * only real evidence about a peer, and it may well arrive on the
-         * second report of it.
-         */
-        role: classifyDeviceRole({
-          platform: platform,
-          name: unmanagedName,
-        }),
+        role: unmanagedRole,
         status: "unknown",
         deviceModel: platform,
         /*
@@ -1383,7 +1454,19 @@ export default class NetworkTopologyUtil {
          * they can only look at.
          */
         ipAddress: ipAddress,
-      });
+      };
+
+      /*
+       * Stamped for the adopt-a-neighbour flow above all: isSnmpWalkableRole
+       * is what decides whether adopting this peer opens on SNMP polling or on
+       * a monitor, and a peer is exactly the node an operator adopts.
+       */
+      applyRoleStamp(
+        unmanagedNode,
+        stampForRoleKey(roleKeyForNode(undefined, unmanagedRole), roleIndex),
+      );
+
+      nodes.push(unmanagedNode);
 
       for (const resolved of groupClaims) {
         nodeIdByClaim.set(resolved, nodeId);

package/Utils/NetworkDevice/DeviceRoleKeyUtil.ts

@@ -0,0 +1,137 @@
+/*
+ * Turns a device role's NAME into its stable KEY.
+ *
+ * Device roles are per-project rows an operator can rename at will, which is
+ * exactly why nothing may identify one by its name. The key is what does the
+ * identifying: it is what the SNMP classifier's answer is matched against,
+ * what a topology payload carries, and what survives the role being renamed.
+ *
+ * The shape is lowerCamelCase, because the eleven built-in roles seeded into
+ * every project already use it ("wirelessAccessPoint", "loadBalancer") and a
+ * key derived from the name "Wireless AP" must be able to look like one of
+ * them. Anything that is not a letter or a digit is a word boundary, so
+ * "PoS Terminal", "pos-terminal" and "POS  terminal!" all derive "posTerminal"
+ * - near-duplicates collapse rather than multiplying.
+ *
+ * Pure and dependency-free: the service derives keys with it on the server and
+ * the tests exercise it directly.
+ */
+
+// Keys are stored in a ShortText column; nothing sensible is this long.
+const MAX_KEY_LENGTH: number = 100;
+
+/*
+ * A name of nothing but punctuation ("---") has no letters to build a key
+ * from. Rather than returning an empty string - which would fail the column's
+ * NOT NULL and surface as a database error - it falls back to this, and the
+ * caller's uniqueness suffixing turns the second one into "role2".
+ */
+export const FALLBACK_DEVICE_ROLE_KEY: string = "role";
+
+export type DeriveDeviceRoleKeyFunction = (name: string) => string;
+
+/**
+ * The key for a role named `name`. Deterministic and case-insensitive over
+ * word separators: it is safe to call twice and get the same answer.
+ */
+export const deriveDeviceRoleKey: DeriveDeviceRoleKeyFunction = (
+  name: string,
+): string => {
+  const words: Array<string> = (name || "")
+    .split(/[^a-zA-Z0-9]+/)
+    .filter((word: string) => {
+      return word.length > 0;
+    });
+
+  if (words.length === 0) {
+    return FALLBACK_DEVICE_ROLE_KEY;
+  }
+
+  /*
+   * A ONE-WORD name is only re-cased at its first letter. A MULTI-word name
+   * has its first word lowercased whole, and every later word capitalised at
+   * the front with its interior left alone.
+   *
+   * Both halves are load-bearing, and for different reasons.
+   *
+   * Lowercasing the head of a multi-word name is what makes the key readable.
+   * Re-casing only its first letter turns "PoS Terminal" into "poSTerminal"
+   * and "IP phone" into "iPPhone", and this key is a column an operator reads
+   * on the settings page. Later words keep their interior for the opposite
+   * reason: "Wireless AP" should read as "wirelessAP" and "SD-WAN Edge" as
+   * "sdWANEdge", because those acronyms are the boundaries a reader navigates
+   * by.
+   *
+   * Leaving a one-word name alone is what makes every derived key a FIXED
+   * POINT of this function. A derived key is always a single run of letters
+   * and digits, so re-deriving it takes this branch and returns it unchanged -
+   * "wirelessAccessPoint" stays "wirelessAccessPoint", and a key that is
+   * accidentally fed back in as a name cannot silently move a role's identity.
+   * It is also honest: a name with no word boundaries has no boundaries to
+   * normalise.
+   */
+  const key: string =
+    words.length === 1
+      ? words[0]!.charAt(0).toLowerCase() + words[0]!.slice(1)
+      : words
+          .map((word: string, index: number): string => {
+            if (index === 0) {
+              return word.toLowerCase();
+            }
+            return word.charAt(0).toUpperCase() + word.slice(1);
+          })
+          .join("");
+
+  /*
+   * A key starting with a digit ("5gRouter") is still a fine identifier here -
+   * it is a lookup key, not a JavaScript name - so only the length is capped.
+   */
+  return key.slice(0, MAX_KEY_LENGTH);
+};
+
+export type BuildUniqueDeviceRoleKeyFunction = (
+  name: string,
+  takenKeys: ReadonlySet<string>,
+) => string;
+
+/**
+ * The key for a role named `name` that no other role in the project holds.
+ *
+ * Two differently-named roles can derive the same key ("PoS Terminal" and
+ * "pos_terminal" both give "posTerminal"), and the column is unique per
+ * project, so the second one has to move. It gets a numeric suffix rather than
+ * a random one so the result stays readable and stable for a given project
+ * state - "posTerminal2", not "posTerminal-f3a9".
+ *
+ * Comparison is case-insensitive because that is how the key is matched when
+ * a role is looked up; two keys differing only in case would collide there.
+ */
+export const buildUniqueDeviceRoleKey: BuildUniqueDeviceRoleKeyFunction = (
+  name: string,
+  takenKeys: ReadonlySet<string>,
+): string => {
+  const taken: Set<string> = new Set<string>();
+  for (const key of takenKeys) {
+    taken.add(key.trim().toLowerCase());
+  }
+
+  const base: string = deriveDeviceRoleKey(name);
+
+  if (!taken.has(base.toLowerCase())) {
+    return base;
+  }
+
+  /*
+   * Bounded so a pathological project cannot spin here. Past the bound the
+   * caller gets the base key back and the database's unique constraint
+   * rejects the create - a loud, correct failure rather than a hang.
+   */
+  for (let suffix: number = 2; suffix < 1000; suffix++) {
+    const candidate: string = `${base}${suffix}`;
+    if (!taken.has(candidate.toLowerCase())) {
+      return candidate;
+    }
+  }
+
+  return base;
+};

package/Utils/NetworkDiscovery/AutoImportRuleMatcher.ts

@@ -34,6 +34,12 @@ import ScanTargetUtil from "./ScanTargetUtil";
  */
 export interface AutoImportRuleCandidate {
   monitorTemplateId?: ObjectID | string | null | undefined;
+  /*
+   * The OID Collection Template imported devices are LINKED to. Purely
+   * carried through the matcher: it never affects whether a host matches,
+   * only what the resulting device collects.
+   */
+  oidTemplateId?: ObjectID | string | null | undefined;
   ipMatchTarget?: string | null | undefined;
   sysNamePattern?: string | null | undefined;
   sysDescrPattern?: string | null | undefined;

package/Utils/NetworkDiscovery/DiscoveredDeviceBuilder.ts

@@ -6,6 +6,7 @@ import SnmpScanConfigUtil, {
   DiscoveryScanSnmpConfig,
 } from "./SnmpScanConfigUtil";
 import { monitoringMethodForDiscoveredHost } from "./DiscoveryImportEligibility";
+import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
 
 /*
  * One discovered host -> one NetworkDevice, the same way everywhere.
@@ -38,14 +39,84 @@ function truncate(value: string, maxLength: number): string {
   return value.length > maxLength ? value.substring(0, maxLength) : value;
 }
 
-/** The name a discovered host imports under: its sysName, or its address. */
-export function buildDeviceName(host: DiscoveredNetworkDevice): string {
-  return truncate(
-    (host.sysName || "").trim() || host.ipAddress,
-    MAX_DEVICE_NAME_LENGTH,
+/**
+ * What a discovered host is CALLED — in the Review dialog, and (clamped by
+ * `buildDeviceName`) on the device it imports as.
+ *
+ * Three sources, in this order, first non-empty wins:
+ *
+ *   1. `sysName`, the name the device gives for itself over SNMP. It stays
+ *      first because it always has been, and because it is the one name the
+ *      device itself asserts: demoting it would silently rename devices that
+ *      import correctly today, which nobody asked for.
+ *   2. `dnsHostname`, its reverse-DNS (PTR) name (OneUptime issue #3529).
+ *      This is the whole point of the addition, and it lands exactly where
+ *      the complaint was: a host with no readable SNMP has no sysName, so
+ *      before this it fell straight through to its address. On an estate that
+ *      keeps DNS records — the reporter's does — that turns a review list of
+ *      "10.18.166.51, 10.18.166.53, ..." into names an operator recognises.
+ *   3. The address, unchanged, when neither name exists.
+ *
+ * Split out of `buildDeviceName` so the dashboard row and the device it
+ * creates cannot disagree: the operator ticks a box next to a name, and that
+ * is the name the device gets. Returned UNTRUNCATED, so a caller that wants
+ * the full name can have it; the Review dialog and the import both go through
+ * `buildDeviceName`, which clamps, so that what is shown is what is created.
+ *
+ * TWO CONSEQUENCES OF NAMING A DEVICE BY DNS, both accepted deliberately:
+ *
+ *   - Anything that matches on `NetworkDevice.name` now sees a name the
+ *     SCANNED NETWORK chose. NetworkSiteAssignmentRule and the label/owner
+ *     rule engines are the live examples: a rule written against a naming
+ *     convention will match differently for a host that used to be called
+ *     "10.18.166.51" and is now called "core-gw.corp.example.com". That is
+ *     inherent to the feature — the alternative is not naming devices by DNS —
+ *     and it is why the name is put through ReverseDnsNameUtil rather than
+ *     trusted. Rules keyed on `hostname` are unaffected: that stays the IP.
+ *   - Names stop being unique per host. Addresses were; PTR names are not, and
+ *     a wildcard reverse zone over a DHCP range gives every host in it the
+ *     same answer. `buildFallbackDeviceName` is the answer to that, and BOTH
+ *     import paths must use it — the rule engine does, and the dashboard's
+ *     Review-dialog import does since the same wildcard case made collisions
+ *     ordinary rather than rare.
+ */
+export function getDiscoveredHostDisplayName(
+  host: DiscoveredNetworkDevice,
+): string {
+  /*
+   * The PTR name is re-normalised here rather than trusted from the column.
+   * `discoveredDevices` is jsonb stored verbatim from the probe's payload, so
+   * "the probe already checked it" holds only for the probe version that
+   * wrote the row — not for a result from an older or a modified probe, and
+   * not for a row written straight through the API. This function is the last
+   * point before the value becomes a rendered line and a slugified device
+   * name, so it is the right place to be sure. See ReverseDnsNameUtil.
+   */
+  /*
+   * `sysName` is read through a typeof guard rather than trusted, for the
+   * same reason `dnsHostname` is normalised: both come out of the same
+   * verbatim jsonb blob, where the declared TypeScript type is a description
+   * of what the probe SHOULD send rather than a guarantee about what is
+   * stored. `(42).trim()` is a TypeError, and since this function became the
+   * dashboard's name line that TypeError would be thrown during render —
+   * taking out the whole Review dialog rather than one row, which is
+   * precisely the failure normalizeDiscoveredHosts was written to end.
+   */
+  const sysName: string =
+    typeof host.sysName === "string" ? host.sysName.trim() : "";
+
+  return (
+    sysName ||
+    normalizeReverseDnsName(host.dnsHostname) ||
+    String(host.ipAddress ?? "")
   );
 }
 
+/** The name a discovered host imports under, clamped to the slug's ceiling. */
+export function buildDeviceName(host: DiscoveredNetworkDevice): string {
+  return truncate(getDiscoveredHostDisplayName(host), MAX_DEVICE_NAME_LENGTH);
+}
+
 /**
  * The fallback name when `buildDeviceName`'s answer is already taken.
  *
@@ -56,12 +127,42 @@ export function buildDeviceName(host: DiscoveredNetworkDevice): string {
  * ceiling.
  */
 export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
-  const suffix: string = ` (${host.ipAddress})`;
+  /*
+   * The address is read through the SAME coercion the display path uses, not
+   * straight out of the jsonb.
+   *
+   * A raw template read turned a missing address into the literal
+   * " (undefined)" and an object one into " ([object Object])" — and those
+   * tokens are IDENTICAL for every such host, so the fallback produced the
+   * same name again and the retry failed on the very duplicate it was
+   * retrying. This function exists to break a name collision; a suffix that
+   * collides is worse than useless.
+   */
+  const address: string = String(host.ipAddress ?? "").trim();
+
+  /*
+   * An address-less host gets no suffix at all rather than an empty pair of
+   * brackets. There is nothing to tell it apart BY, so the honest outcome is
+   * the base name unchanged — the caller's create then fails on the duplicate,
+   * which is the truth, instead of succeeding under a name that pretends to
+   * carry an address.
+   */
+  const suffix: string = address ? ` (${address})` : "";
+
   const baseName: string = buildDeviceName(host);
 
-  return (
+  /*
+   * Clamped as a whole, not just the base. `Math.max(1, ...)` keeps a
+   * character of the base name however long the suffix is, so an absurd
+   * address — the field is never validated on this path, it is whatever the
+   * probe wrote — could compose a name past the ceiling and fail the create on
+   * the slug's own length, which is the exact overflow the ceiling exists to
+   * prevent.
+   */
+  return truncate(
     truncate(baseName, Math.max(1, MAX_DEVICE_NAME_LENGTH - suffix.length)) +
-    suffix
+      suffix,
+    MAX_DEVICE_NAME_LENGTH,
   );
 }
 
@@ -119,14 +220,40 @@ export function buildNetworkDeviceFromDiscoveredHost(data: {
    * and decides, which is the existing contract for hand-made devices.
    */
   autoApplyVendorHealthTemplate?: boolean | undefined;
+  /*
+   * The OID Collection Template an auto-import rule linked this device to.
+   * Set at create so the device collects its type's OIDs from its very first
+   * poll, with nobody having to touch it afterwards.
+   */
+  oidTemplateId?: ObjectID | undefined;
 }): NetworkDevice {
   const host: DiscoveredNetworkDevice = data.host;
 
   const device: NetworkDevice = new NetworkDevice();
   device.projectId = data.projectId;
   device.name = data.name || buildDeviceName(host);
-  // The address is the device's hostname AND the registered-host dedup key.
-  device.hostname = host.ipAddress;
+  /*
+   * The address is the device's hostname AND the registered-host dedup key.
+   *
+   * It stays the ADDRESS even when the host resolved a PTR name, which is
+   * what issue #3529 asked for in as many words ("retain the IP address as
+   * the address/IP field"), and what the rest of the system needs: this
+   * column is what the ingest path matches a scan's results against
+   * (NetworkDeviceService.getRegisteredHostnames), what the SNMP poller
+   * dials, and what a trap's source IP is correlated to. Storing a name here
+   * would make a device stop polling the day its reverse zone changed, and
+   * would make the same host import twice — once by address, once by name.
+   * The PTR record names the device; it does not address it.
+   *
+   * COERCED, because the dedup key has to be a string. The value comes out of
+   * jsonb, and `getRegisteredHostnames` matches it with `Set.has()` against
+   * hostnames read back from the database — and `Set.has` does not coerce, so
+   * a numeric address stored raw would never match its own registered device
+   * and the host would import again on every review. The dashboard path is
+   * already covered by normalizeDiscoveredHosts; this makes the builder safe
+   * for the rule engine and for any future caller that holds a raw row.
+   */
+  device.hostname = String(host.ipAddress ?? "").trim();
 
   if (host.sysDescr) {
     device.description = truncate(host.sysDescr, MAX_DEVICE_DESCRIPTION_LENGTH);
@@ -145,6 +272,10 @@ export function buildNetworkDeviceFromDiscoveredHost(data: {
     return device;
   }
 
+  if (data.oidTemplateId) {
+    device.oidTemplateId = data.oidTemplateId;
+  }
+
   if (data.autoApplyVendorHealthTemplate) {
     device.autoApplyVendorHealthTemplate = true;
   }

package/Utils/NetworkDiscovery/DiscoveredHostUtil.ts

@@ -1,4 +1,5 @@
 import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
 
 /*
  * Normalisation for a scan's stored results, shared by every reader of the
@@ -40,7 +41,12 @@ function isDiscoveredHostObject(
  *     import, so whether a device already in the inventory got created a
  *     second time depended on which order the probe happened to list them in.
  *
- * All three are fixed here rather than at each call site, so the row the
+ * A fourth was added with reverse DNS (issue #3529) and is not a probe bug at
+ * all — `dnsHostname` is a value the SCANNED NETWORK chooses, so it is
+ * untrusted by construction rather than by accident, and it is normalised
+ * here for the same reason: one reading of the payload for every reader.
+ *
+ * All of them are fixed here rather than at each call site, so the row the
  * operator sees, the badge above it, the list Import walks, and the hosts an
  * auto-import rule evaluates can never be working from different readings of
  * the same payload.
@@ -60,13 +66,59 @@ export function normalizeDiscoveredHosts(
      * truthy, so it used to pass selectability and import as a Network Device
      * whose hostname was a single space.
      */
-    cleaned.push({
+    const normalized: DiscoveredNetworkDevice = {
       ...host,
       ipAddress:
         host.ipAddress === undefined || host.ipAddress === null
           ? ""
           : String(host.ipAddress).trim(),
-    });
+    };
+
+    /*
+     * `sysName` is read straight out of the jsonb, its declared type is not
+     * enforced by anything, and every reader calls a string method on it. A
+     * numeric sysName reached getDiscoveredHostDisplayName and threw inside
+     * the Review dialog's render, taking out the whole modal rather than one
+     * row — the same failure the null-row case above is about.
+     *
+     * A non-string is blanked rather than STRINGIFIED, which is where this
+     * differs from the address above. `String(null)` is "null" and
+     * `String({})` is "[object Object]", and both are truthy — so stringifying
+     * would not merely fail to name the host, it would win the naming contest
+     * outright and create a device called "null", beating a perfectly good PTR
+     * record on the very same row. An empty string is falsy, so naming falls
+     * through to `dnsHostname` and then to the address, which is exactly what
+     * a host with no readable system name deserves.
+     *
+     * Only rewritten when it is NOT already a string, so a host that never had
+     * the key does not gain an empty one — `sysName` is optional and
+     * `"sysName" in host` is a question other code is entitled to ask.
+     */
+    if (host.sysName !== undefined && typeof host.sysName !== "string") {
+      normalized.sysName = "";
+    }
+
+    /*
+     * The PTR name gets the same treatment, for a sharper version of the same
+     * reason (OneUptime issue #3529): unlike every other field here, its
+     * value was chosen by whoever runs DNS for the scanned subnet — routinely
+     * not this project — and it is stored verbatim in jsonb. So the rules
+     * about what a name may contain are applied on the way OUT of the column
+     * as well as on the way in, and anything that fails them is DELETED
+     * rather than blanked, so a reader that checks `if (host.dnsHostname)`
+     * and a reader that checks `"dnsHostname" in host` cannot disagree.
+     */
+    const dnsHostname: string | undefined = normalizeReverseDnsName(
+      host.dnsHostname,
+    );
+
+    if (dnsHostname) {
+      normalized.dnsHostname = dnsHostname;
+    } else {
+      delete normalized.dnsHostname;
+    }
+
+    cleaned.push(normalized);
   }
 
   // An address the scan reports as registered is registered on every row.