@oneuptime/common 11.6.1 → 11.7.0

package/Server/Utils/Monitor/DnsResolutionCache.ts

@@ -0,0 +1,129 @@
+import dns from "dns";
+
+/*
+ * Small positive/negative DNS cache for correlating datagram source IPs
+ * (SNMP traps, syslog) to NetworkDevices registered by DNS name instead of
+ * IP address. Every trap from such a device used to be silently dropped —
+ * the ingest paths match hostname == source IP by exact string — so this
+ * cache lets them resolve the handful of DNS-named devices per probe
+ * without hammering the resolver on every datagram.
+ *
+ * Failures are cached too (as an empty address list) so an unresolvable
+ * hostname does not retry on every trap. The resolver and clock are
+ * injectable for tests.
+ */
+
+interface DnsCacheEntry {
+  addresses: Array<string>;
+  expiresAt: number;
+}
+
+export type ResolveHostnameFunction = (
+  hostname: string,
+) => Promise<Array<string>>;
+
+export type NowFunction = () => number;
+
+/*
+ * dns.lookup has no timeout of its own and runs on the shared libuv
+ * threadpool, so a wedged resolver would otherwise stall the trap/syslog
+ * ingest path. The race rejects after this budget; the failure is then
+ * negative-cached like any other resolution error.
+ */
+const DEFAULT_RESOLVE_TIMEOUT_MS: number = 2000;
+
+const defaultResolver: ResolveHostnameFunction = async (
+  hostname: string,
+): Promise<Array<string>> => {
+  const lookup: Promise<Array<dns.LookupAddress>> = dns.promises.lookup(
+    hostname,
+    {
+      all: true,
+      verbatim: true,
+    },
+  );
+
+  const timeout: Promise<never> = new Promise<never>(
+    (_resolve: (value: never) => void, reject: (reason: Error) => void) => {
+      const timer: ReturnType<typeof setTimeout> = setTimeout(() => {
+        reject(new Error(`DNS lookup for ${hostname} timed out`));
+      }, DEFAULT_RESOLVE_TIMEOUT_MS);
+      // Never keep the process alive just for this timer.
+      timer.unref?.();
+    },
+  );
+
+  const results: Array<dns.LookupAddress> = await Promise.race([
+    lookup,
+    timeout,
+  ]);
+
+  return results.map((result: dns.LookupAddress) => {
+    return result.address;
+  });
+};
+
+export class DnsResolutionCache {
+  private cache: Map<string, DnsCacheEntry> = new Map<string, DnsCacheEntry>();
+
+  private ttlInMs: number;
+  private maxEntries: number;
+  private resolver: ResolveHostnameFunction;
+  private now: NowFunction;
+
+  public constructor(options?: {
+    ttlInMs?: number | undefined;
+    maxEntries?: number | undefined;
+    resolver?: ResolveHostnameFunction | undefined;
+    now?: NowFunction | undefined;
+  }) {
+    this.ttlInMs = options?.ttlInMs ?? 5 * 60 * 1000;
+    this.maxEntries = options?.maxEntries ?? 5000;
+    this.resolver = options?.resolver ?? defaultResolver;
+    this.now = options?.now ?? Date.now;
+  }
+
+  /*
+   * Addresses for a hostname, from cache when fresh. Resolution errors
+   * return (and cache) an empty list — callers treat that as "no match",
+   * never as an exception.
+   */
+  public async resolve(hostname: string): Promise<Array<string>> {
+    const key: string = hostname.toLowerCase();
+    const nowInMs: number = this.now();
+
+    const cached: DnsCacheEntry | undefined = this.cache.get(key);
+    if (cached && cached.expiresAt > nowInMs) {
+      return cached.addresses;
+    }
+
+    let addresses: Array<string> = [];
+    try {
+      addresses = await this.resolver(hostname);
+    } catch {
+      // Negative-cache resolution failures.
+      addresses = [];
+    }
+
+    if (this.cache.size >= this.maxEntries && !this.cache.has(key)) {
+      // Bound memory: evict the oldest entry (Map preserves insert order).
+      const oldestKey: string | undefined = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+
+    this.cache.set(key, {
+      addresses: addresses,
+      expiresAt: nowInMs + this.ttlInMs,
+    });
+
+    return addresses;
+  }
+
+  public clear(): void {
+    this.cache.clear();
+  }
+}
+
+export default DnsResolutionCache;

package/Server/Utils/Monitor/MonitorResource.ts

@@ -9,13 +9,10 @@ import logger from "../Logger";
 import MonitorCriteriaEvaluator from "./MonitorCriteriaEvaluator";
 import MonitorLogUtil from "./MonitorLogUtil";
 import MonitorMetricUtil from "./MonitorMetricUtil";
-import NetworkInventoryUtil from "./NetworkInventoryUtil";
-import SnmpInterfaceRateUtil from "./SnmpInterfaceRateUtil";
 import DataToProcess from "./DataToProcess";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import Dictionary from "../../../Types/Dictionary";
 import BadDataException from "../../../Types/Exception/BadDataException";
-import { JSONObject } from "../../../Types/JSON";
 import Semaphore, { SemaphoreMutex } from "../../Infrastructure/Semaphore";
 import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
@@ -293,34 +290,11 @@ export default class MonitorResourceUtil {
           probeName = monitorProbe.probe?.name || undefined;
 
           /*
-           * SNMP interface rates (bandwidth, utilization, errors/sec) are
-           * deltas against the previous check's counters — computed here,
-           * while the previous log is still available, so the computed
-           * values flow into metrics, criteria, and the stored log below.
+           * Network Device monitors no longer flow through here: they are
+           * not probeable — the NetworkDevice resource owns its own polling
+           * and NetworkDeviceWalkUtil computes interface rates, syncs
+           * inventory, and evaluates watching monitors on each device walk.
            */
-          if (monitor.monitorType === MonitorType.NetworkDevice) {
-            SnmpInterfaceRateUtil.attachInterfaceRates({
-              probeMonitorResponse: dataToProcess as ProbeMonitorResponse,
-              previousStepLog: (
-                monitorProbe.lastMonitoringLog as JSONObject | undefined
-              )?.[
-                (dataToProcess as ProbeMonitorResponse).monitorStepId.toString()
-              ] as JSONObject | undefined,
-            });
-
-            /*
-             * Sync the NetworkDevice/NetworkInterface inventory from the
-             * walk, then prune the response to monitored interfaces so
-             * criteria and metrics ignore muted ports. Trap events carry
-             * no walk data — nothing to sync.
-             */
-            if (!isSnmpTrapEvent) {
-              await NetworkInventoryUtil.updateFromWalk({
-                monitor: monitor,
-                dataToProcess: dataToProcess as ProbeMonitorResponse,
-              });
-            }
-          }
 
           if (!isSnmpTrapEvent) {
             await MonitorProbeService.updateOneBy({

package/Server/Utils/Monitor/NetworkDeviceHydrationUtil.ts

@@ -1,5 +1,7 @@
 import NetworkDevice from "../../../Models/DatabaseModels/NetworkDevice";
 import NetworkDeviceService from "../../Services/NetworkDeviceService";
+import MonitorStepSnmpMonitor from "../../../Types/Monitor/MonitorStepSnmpMonitor";
+import SnmpOid from "../../../Types/Monitor/SnmpMonitor/SnmpOid";
 import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
 import QueryHelper from "../../Types/Database/QueryHelper";
 import LIMIT_MAX from "../../../Types/Database/LimitMax";
@@ -12,6 +14,9 @@ import SnmpSecurityLevel from "../../../Types/Monitor/SnmpMonitor/SnmpSecurityLe
 import SnmpAuthProtocol from "../../../Types/Monitor/SnmpMonitor/SnmpAuthProtocol";
 import SnmpPrivProtocol from "../../../Types/Monitor/SnmpMonitor/SnmpPrivProtocol";
 import ObjectID from "../../../Types/ObjectID";
+import IP from "../../../Types/IP/IP";
+import IpCanonicalUtil from "../../../Utils/IpCanonicalUtil";
+import DnsResolutionCache from "./DnsResolutionCache";
 import logger from "../Logger";
 
 /*
@@ -27,10 +32,76 @@ export interface HydratableMonitor {
 }
 
 export default class NetworkDeviceHydrationUtil {
-  // Accepts Monitor and MonitorTest alike (structural: monitorType + monitorSteps).
-  public static async hydrateNetworkDeviceMonitors(
+  /*
+   * The device columns needed to assemble a probe-executable SNMP config.
+   * Shared by monitor hydration below and the device polling claim
+   * endpoint, so the two can never drift apart on which credentials they
+   * load.
+   */
+  public static readonly snmpConfigSelect: {
+    _id: true;
+    hostname: true;
+    snmpVersion: true;
+    snmpCommunityString: true;
+    snmpPort: true;
+    snmpV3Auth: true;
+    snmpV3SecurityLevel: true;
+    snmpV3Username: true;
+    snmpV3AuthProtocol: true;
+    snmpV3AuthKey: true;
+    snmpV3PrivProtocol: true;
+    snmpV3PrivKey: true;
+  } = {
+    _id: true,
+    hostname: true,
+    snmpVersion: true,
+    snmpCommunityString: true,
+    snmpPort: true,
+    snmpV3Auth: true,
+    snmpV3SecurityLevel: true,
+    snmpV3Username: true,
+    snmpV3AuthProtocol: true,
+    snmpV3AuthKey: true,
+    snmpV3PrivProtocol: true,
+    snmpV3PrivKey: true,
+  };
+
+  /*
+   * Assembles the concrete SNMP config a stateless probe can execute from a
+   * device's stored connection identity. The caller chooses what to collect
+   * (OIDs / interface walk) — for device polling those come from the
+   * device's own snmpOids/walkInterfaces columns.
+   */
+  public static buildSnmpMonitorConfig(data: {
+    device: NetworkDevice;
+    oids: Array<SnmpOid>;
+    monitorInterfaces: boolean;
+  }): MonitorStepSnmpMonitor {
+    return {
+      snmpVersion: NetworkDeviceHydrationUtil.parseSnmpVersion(
+        data.device.snmpVersion,
+      ),
+      hostname: data.device.hostname || "",
+      port: data.device.snmpPort || 161,
+      communityString: data.device.snmpCommunityString || undefined,
+      snmpV3Auth: NetworkDeviceHydrationUtil.buildSnmpV3Auth(data.device),
+      oids: data.oids,
+      timeout: 5000,
+      retries: 3,
+      monitorInterfaces: data.monitorInterfaces,
+    };
+  }
+
+  /*
+   * Parses which NetworkDevice IDs a batch of Network Device monitors
+   * reference in their steps (step.data.networkDeviceMonitor.networkDeviceId).
+   * Non-NetworkDevice monitors are skipped. Shared by hydration below and by
+   * the site rollup engine, which stamps device status on monitor status
+   * changes - keep this the single copy of the step-parsing logic.
+   */
+  public static getReferencedNetworkDeviceIds(
     monitors: Array<HydratableMonitor>,
-  ): Promise<void> {
+  ): Array<string> {
     const deviceIds: Set<string> = new Set();
 
     for (const monitor of monitors) {
@@ -48,28 +119,25 @@ export default class NetworkDeviceHydrationUtil {
       }
     }
 
-    if (deviceIds.size === 0) {
+    return Array.from(deviceIds);
+  }
+
+  // Accepts Monitor and MonitorTest alike (structural: monitorType + monitorSteps).
+  public static async hydrateNetworkDeviceMonitors(
+    monitors: Array<HydratableMonitor>,
+  ): Promise<void> {
+    const deviceIds: Array<string> =
+      NetworkDeviceHydrationUtil.getReferencedNetworkDeviceIds(monitors);
+
+    if (deviceIds.length === 0) {
       return;
     }
 
     const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy({
       query: {
-        _id: QueryHelper.any(Array.from(deviceIds)),
-      },
-      select: {
-        _id: true,
-        hostname: true,
-        snmpVersion: true,
-        snmpCommunityString: true,
-        snmpPort: true,
-        snmpV3Auth: true,
-        snmpV3SecurityLevel: true,
-        snmpV3Username: true,
-        snmpV3AuthProtocol: true,
-        snmpV3AuthKey: true,
-        snmpV3PrivProtocol: true,
-        snmpV3PrivKey: true,
+        _id: QueryHelper.any(deviceIds),
       },
+      select: NetworkDeviceHydrationUtil.snmpConfigSelect,
       limit: LIMIT_MAX,
       skip: 0,
       props: {
@@ -107,20 +175,19 @@ export default class NetworkDeviceHydrationUtil {
           continue;
         }
 
-        step.data.snmpMonitor = {
-          snmpVersion: NetworkDeviceHydrationUtil.parseSnmpVersion(
-            device.snmpVersion,
-          ),
-          hostname: device.hostname,
-          port: device.snmpPort || 161,
-          communityString: device.snmpCommunityString || undefined,
-          snmpV3Auth: NetworkDeviceHydrationUtil.buildSnmpV3Auth(device),
-          oids: step.data.networkDeviceMonitor?.oids || [],
-          timeout: 5000,
-          retries: 3,
-          monitorInterfaces:
-            step.data.networkDeviceMonitor?.monitorInterfaces !== false,
-        };
+        /*
+         * Legacy path: reads the step's own (deprecated) oids and
+         * monitorInterfaces. Only monitor TESTS still flow through here —
+         * regular Network Device monitors are no longer probe-executed
+         * (the device polls itself; see NetworkDevicePollUtil).
+         */
+        step.data.snmpMonitor =
+          NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+            device: device,
+            oids: step.data.networkDeviceMonitor?.oids || [],
+            monitorInterfaces:
+              step.data.networkDeviceMonitor?.monitorInterfaces !== false,
+          });
       }
     }
   }
@@ -183,21 +250,63 @@ export default class NetworkDeviceHydrationUtil {
   }
 
   /*
-   * Resolves which NetworkDevices (polled by the given probe) match a trap
-   * source IP. Used by the trap ingest to fan traps out to device monitors.
+   * Resolves which NetworkDevices (polled by the given probe) match a
+   * datagram source IP — SNMP traps and probe-forwarded syslog both route
+   * through here. Exact hostname == source-IP match first; devices
+   * registered by DNS name are matched by resolving their hostnames
+   * through a shared positive/negative cache, so a device added as
+   * "switch-01.example.com" still receives its traps and syslog.
    */
   public static async findDevicesByProbeAndSource(data: {
     probeId: ObjectID;
     sourceIpAddress: string;
+    // Extra columns callers need (syslog attribution wants `name`).
+    select?: { name?: boolean | undefined } | undefined;
   }): Promise<Array<NetworkDevice>> {
-    return NetworkDeviceService.findBy({
+    const select: {
+      _id: boolean;
+      projectId: boolean;
+      name?: boolean | undefined;
+    } = {
+      _id: true,
+      projectId: true,
+      ...(data.select?.name ? { name: true } : {}),
+    };
+
+    const exactMatches: Array<NetworkDevice> =
+      await NetworkDeviceService.findBy({
+        query: {
+          probeId: data.probeId,
+          hostname: data.sourceIpAddress,
+        },
+        select: select,
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (exactMatches.length > 0) {
+      return exactMatches;
+    }
+
+    /*
+     * Fallback for the two spellings the exact match cannot see:
+     * (a) IPv6-literal hostnames written differently than the datagram's
+     *     normalized source (2001:DB8::1 vs 2001:db8::1) — compared
+     *     canonically, and
+     * (b) DNS-named devices — resolved through a shared cache and their
+     *     addresses compared canonically.
+     * Only runs when the exact match found nothing.
+     */
+    const candidates: Array<NetworkDevice> = await NetworkDeviceService.findBy({
       query: {
         probeId: data.probeId,
-        hostname: data.sourceIpAddress,
       },
       select: {
-        _id: true,
-        projectId: true,
+        ...select,
+        hostname: true,
       },
       limit: LIMIT_MAX,
       skip: 0,
@@ -205,5 +314,71 @@ export default class NetworkDeviceHydrationUtil {
         isRoot: true,
       },
     });
+
+    const canonicalSource: string = IpCanonicalUtil.canonicalize(
+      data.sourceIpAddress,
+    );
+
+    const literalMatches: Array<NetworkDevice> = [];
+    const dnsCandidates: Array<NetworkDevice> = [];
+
+    for (const device of candidates) {
+      const hostname: string = device.hostname?.trim() || "";
+
+      if (!hostname) {
+        continue;
+      }
+
+      if (IP.isIP(hostname)) {
+        if (IpCanonicalUtil.canonicalize(hostname) === canonicalSource) {
+          literalMatches.push(device);
+        }
+        continue;
+      }
+
+      dnsCandidates.push(device);
+    }
+
+    if (literalMatches.length > 0) {
+      return literalMatches;
+    }
+
+    /*
+     * DNS resolution runs in parallel (deduplicated per hostname) so a
+     * cold cache with a slow resolver costs one lookup timeout, not one
+     * per device — this is on the trap/syslog ingest path.
+     */
+    const uniqueHostnames: Array<string> = [
+      ...new Set(
+        dnsCandidates.map((device: NetworkDevice) => {
+          return device.hostname!.trim().toLowerCase();
+        }),
+      ),
+    ];
+
+    const addressesByHostname: Map<string, Array<string>> = new Map(
+      await Promise.all(
+        uniqueHostnames.map(
+          async (hostname: string): Promise<[string, Array<string>]> => {
+            return [
+              hostname,
+              await NetworkDeviceHydrationUtil.dnsCache.resolve(hostname),
+            ];
+          },
+        ),
+      ),
+    );
+
+    return dnsCandidates.filter((device: NetworkDevice) => {
+      const addresses: Array<string> =
+        addressesByHostname.get(device.hostname!.trim().toLowerCase()) || [];
+
+      return addresses.some((address: string) => {
+        return IpCanonicalUtil.canonicalize(address) === canonicalSource;
+      });
+    });
   }
+
+  // Shared across trap and syslog ingest; 5-minute TTL, failure-cached.
+  private static dnsCache: DnsResolutionCache = new DnsResolutionCache();
 }