@oneuptime/common 12.0.31 → 12.0.33

package/Utils/EnterpriseLicense/EnterpriseLicenseUsage.ts

@@ -1,4 +1,4 @@
-import OneUptimeDate from "../../Types/Date";
+import EnterpriseLicenseUserCountSource from "../../Types/EnterpriseLicense/EnterpriseLicenseUserCountSource";
 
 /*
  * Usage reported by one self-hosted instance of an enterprise license.
@@ -7,11 +7,37 @@ import OneUptimeDate from "../../Types/Date";
  * on staging, production and gov-cloud consumes a single seat.
  */
 export interface EnterpriseLicenseInstanceUsage {
+  /*
+   * Registration is the initial communication until the instance sends its
+   * first usage report.
+   */
+  createdAt?: Date | undefined;
   userCount?: number | undefined;
   userEmailHashes?: Array<string> | undefined;
   lastReportedAt?: Date | undefined;
 }
 
+export interface EffectiveEnterpriseLicenseUserCountOptions {
+  instances: Array<EnterpriseLicenseInstanceUsage>;
+  storedUserCount?: number | null | undefined;
+  storedUserCountUpdatedAt?: Date | undefined;
+  storedUserCountSource?: EnterpriseLicenseUserCountSource | undefined;
+  legacyUserCount?: number | null | undefined;
+  legacyUserCountUpdatedAt?: Date | undefined;
+  /*
+   * Callers that just replaced/deleted modern rows know the stored aggregate
+   * came from those rows. They can suppress the one-time compatibility path
+   * for license records created before dedicated legacy fields existed.
+   */
+  allowStoredUserCountAsLegacyFallback?: boolean | undefined;
+  now: Date;
+}
+
+export interface EffectiveEnterpriseLicenseUserCount {
+  userCount: number | null;
+  source: EnterpriseLicenseUserCountSource | null;
+}
+
 export default class EnterpriseLicenseUsageUtil {
   /*
    * How many days before a license expires that expiry reminder emails
@@ -41,11 +67,11 @@ export default class EnterpriseLicenseUsageUtil {
     )}`;
   }
   /*
-   * Instances that stopped reporting (for example a decommissioned staging
-   * environment) stop counting towards the seat total after this many days,
-   * but are still listed so the customer can see them.
+   * An instance is inactive once it has gone this many complete days without
+   * communicating with oneuptime.com. Inactive instances stay visible, but
+   * their users no longer consume seats.
    */
-  public static readonly InstanceUsageFreshnessInDays: number = 30;
+  public static readonly InstanceUsageFreshnessInDays: number = 7;
 
   // SHA-256 hex digest.
   private static readonly emailHashRegex: RegExp = /^[a-f0-9]{64}$/;
@@ -136,17 +162,171 @@ export default class EnterpriseLicenseUsageUtil {
     instance: EnterpriseLicenseInstanceUsage,
     now: Date,
   ): boolean {
-    if (!instance.lastReportedAt) {
-      // Registered (license key validated) but never reported usage yet.
+    const lastCommunicatedAt: Date | undefined =
+      this.getInstanceLastCommunicatedAt(instance);
+
+    if (!lastCommunicatedAt) {
       return false;
     }
 
-    const staleBefore: Date = OneUptimeDate.addRemoveDays(
-      now,
-      -this.InstanceUsageFreshnessInDays,
+    const inactiveAfterInMilliseconds: number =
+      this.InstanceUsageFreshnessInDays * 24 * 60 * 60 * 1000;
+    const staleBefore: number = now.getTime() - inactiveAfterInMilliseconds;
+
+    /*
+     * Strictly greater than: at the exact seven-day boundary the instance has
+     * gone a full week without communicating and must already be inactive.
+     * Elapsed milliseconds are intentional; a daylight-saving transition
+     * must not shorten or extend the week.
+     */
+    return lastCommunicatedAt.getTime() > staleBefore;
+  }
+
+  public static getInstanceLastCommunicatedAt(
+    instance: EnterpriseLicenseInstanceUsage,
+  ): Date | undefined {
+    return instance.lastReportedAt || instance.createdAt;
+  }
+
+  /* A registration is active, but only a real report is modern seat data. */
+  public static hasActiveReportedInstanceUsage(
+    instances: Array<EnterpriseLicenseInstanceUsage>,
+    now: Date,
+  ): boolean {
+    return instances.some(
+      (instance: EnterpriseLicenseInstanceUsage): boolean => {
+        return (
+          Boolean(instance.lastReportedAt) &&
+          this.isInstanceCountedTowardsUsage(instance, now)
+        );
+      },
     );
+  }
+
+  public static isTimestampWithinUsageWindow(
+    timestamp: Date | undefined,
+    now: Date,
+  ): boolean {
+    return timestamp
+      ? this.isInstanceCountedTowardsUsage({ lastReportedAt: timestamp }, now)
+      : false;
+  }
+
+  public static hasReportedInstanceUsage(
+    instances: Array<EnterpriseLicenseInstanceUsage>,
+  ): boolean {
+    return instances.some(
+      (instance: EnterpriseLicenseInstanceUsage): boolean => {
+        return Boolean(instance.lastReportedAt);
+      },
+    );
+  }
+
+  /*
+   * Choose between modern per-instance reports and a separately persisted
+   * legacy license-wide heartbeat. The stored count fallback exists only for
+   * records written before those dedicated legacy columns were introduced;
+   * seeing any historical modern report proves that aggregate is not legacy.
+   * Once every authoritative communication timestamp is a week old, usage is
+   * zero.
+   */
+  public static getEffectiveUserCount(
+    options: EffectiveEnterpriseLicenseUserCountOptions,
+  ): number | null {
+    return this.getEffectiveUserCountAndSource(options).userCount;
+  }
+
+  public static getEffectiveUserCountAndSource(
+    options: EffectiveEnterpriseLicenseUserCountOptions,
+  ): EffectiveEnterpriseLicenseUserCount {
+    if (this.hasActiveReportedInstanceUsage(options.instances, options.now)) {
+      return {
+        userCount: this.getUniqueUserCount(options.instances, options.now),
+        source: EnterpriseLicenseUserCountSource.Instance,
+      };
+    }
+
+    if (
+      this.isTimestampWithinUsageWindow(
+        options.legacyUserCountUpdatedAt,
+        options.now,
+      )
+    ) {
+      return {
+        userCount: options.legacyUserCount ?? null,
+        source: EnterpriseLicenseUserCountSource.Legacy,
+      };
+    }
+
+    const hasRecentRegistration: boolean = options.instances.some(
+      (instance: EnterpriseLicenseInstanceUsage): boolean => {
+        return (
+          !instance.lastReportedAt &&
+          this.isInstanceCountedTowardsUsage(instance, options.now)
+        );
+      },
+    );
+    const hasRecentLegacyReport: boolean = options.storedUserCountUpdatedAt
+      ? this.isTimestampWithinUsageWindow(
+          options.storedUserCountUpdatedAt,
+          options.now,
+        )
+      : false;
+    const isExplicitLegacyFallback: boolean =
+      options.storedUserCountSource ===
+        EnterpriseLicenseUserCountSource.Legacy &&
+      !options.legacyUserCountUpdatedAt &&
+      hasRecentLegacyReport;
+    const canUseCompatibilityFallback: boolean =
+      options.allowStoredUserCountAsLegacyFallback !== false &&
+      options.storedUserCountSource !==
+        EnterpriseLicenseUserCountSource.Instance &&
+      !options.legacyUserCountUpdatedAt &&
+      !this.hasReportedInstanceUsage(options.instances);
+
+    if (
+      isExplicitLegacyFallback ||
+      (canUseCompatibilityFallback &&
+        (hasRecentRegistration || hasRecentLegacyReport))
+    ) {
+      return {
+        userCount: options.storedUserCount ?? null,
+        source: EnterpriseLicenseUserCountSource.Legacy,
+      };
+    }
+
+    if (
+      options.instances.length === 0 &&
+      (options.storedUserCount === undefined ||
+        options.storedUserCount === null) &&
+      !options.storedUserCountUpdatedAt &&
+      (options.legacyUserCount === undefined ||
+        options.legacyUserCount === null) &&
+      !options.legacyUserCountUpdatedAt &&
+      !options.storedUserCountSource
+    ) {
+      return {
+        userCount: null,
+        source: null,
+      };
+    }
+
+    let inactiveUsageSource: EnterpriseLicenseUserCountSource | null =
+      options.storedUserCountSource || null;
+
+    if (
+      !inactiveUsageSource &&
+      this.hasReportedInstanceUsage(options.instances)
+    ) {
+      inactiveUsageSource = EnterpriseLicenseUserCountSource.Instance;
+    } else if (!inactiveUsageSource && options.legacyUserCountUpdatedAt) {
+      inactiveUsageSource = EnterpriseLicenseUserCountSource.Legacy;
+    }
 
-    return instance.lastReportedAt.getTime() >= staleBefore.getTime();
+    return {
+      userCount: 0,
+      source: inactiveUsageSource,
+    };
   }
 
   /*

package/Utils/Monitor/MonitorMetricType.ts

@@ -1,5 +1,16 @@
 import AggregationType from "../../Types/BaseDatabase/AggregationType";
-import { CheckOn } from "../../Types/Monitor/CriteriaFilter";
+import { CheckOn, CriteriaFilter } from "../../Types/Monitor/CriteriaFilter";
+import {
+  DatabaseMetricCategory,
+  DatabaseMetricDefinition,
+  getAllDatabaseMetrics,
+  getDatabaseMetricByMetricType,
+  getDatabaseMetricCategoryDescription,
+  getDatabaseMetricCategoryOrder,
+  getDatabaseMetricsByCategory,
+  getDatabaseMetricsForEngine,
+} from "../../Types/Monitor/DatabaseMetricCatalog";
+import SqlDatabaseType from "../../Types/Monitor/SqlDatabaseType";
 import MonitorMetricType from "../../Types/Monitor/MonitorMetricType";
 import MonitorType, {
   MonitorTypeHelper,
@@ -20,6 +31,19 @@ class MonitorMetricTypeUtil {
   public static getAggregationTypeByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
   ): AggregationType {
+    /*
+     * Database Health series carry their own aggregation in the catalog, so
+     * they resolve here instead of adding ~40 cases to this switch (and to
+     * the four other switches in this file). The catalog is the one place a
+     * new database metric has to be declared.
+     */
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+
+    if (databaseMetric) {
+      return databaseMetric.defaultAggregation;
+    }
+
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return AggregationType.Avg;
@@ -275,6 +299,22 @@ class MonitorMetricTypeUtil {
       ];
     }
 
+    if (monitorType === MonitorType.Database) {
+      /*
+       * Availability first, then every catalog series in category order.
+       * Engine filtering happens in getDatabaseMetricCategories, which is
+       * the only caller that knows which engine the monitor points at - this
+       * list is the full capability set for the monitor type.
+       */
+      return [
+        MonitorMetricType.IsOnline,
+        MonitorMetricType.ResponseTime,
+        ...getAllDatabaseMetrics().map((metric: DatabaseMetricDefinition) => {
+          return metric.metricType;
+        }),
+      ];
+    }
+
     if (
       monitorType === MonitorType.DNS ||
       monitorType === MonitorType.DNSSEC ||
@@ -308,6 +348,14 @@ class MonitorMetricTypeUtil {
    */
   public static getMonitorMetricCategoriesByMonitorType(
     monitorType: MonitorType,
+    /*
+     * Database Health only. When the caller knows which engine the monitor
+     * is pointed at, pass it and the cards drop the series that engine can
+     * never write - so a MySQL monitor does not show a permanently empty
+     * "Transaction ID Used" chart. Omitting it shows the full capability
+     * set, which is the right fallback when the engine is not loaded yet.
+     */
+    databaseType?: SqlDatabaseType | undefined,
   ): Array<MonitorMetricCategory> {
     if (monitorType === MonitorType.Server) {
       return [
@@ -375,6 +423,10 @@ class MonitorMetricTypeUtil {
       ];
     }
 
+    if (monitorType === MonitorType.Database) {
+      return this.getDatabaseMetricCategories(databaseType);
+    }
+
     if (monitorType === MonitorType.NetworkDevice) {
       return [
         {
@@ -423,6 +475,13 @@ class MonitorMetricTypeUtil {
       return "Total Connection Time (DNS + TCP)";
     }
 
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+
+    if (databaseMetric) {
+      return databaseMetric.friendlyName;
+    }
+
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "Response Time";
@@ -534,6 +593,13 @@ class MonitorMetricTypeUtil {
   public static getLegendUnitByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
   ): string {
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+
+    if (databaseMetric) {
+      return databaseMetric.unit;
+    }
+
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "ms";
@@ -619,6 +685,13 @@ class MonitorMetricTypeUtil {
       return "Total time spent resolving the hostname (when needed) and establishing the TCP connection.";
     }
 
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+
+    if (databaseMetric) {
+      return databaseMetric.description;
+    }
+
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "Response time is the time taken for a server to respond to a request. It is the sum of the time spent waiting to establish the connection, the time spent waiting for the request to be processed, and the time spent waiting for the response to be sent.";
@@ -714,6 +787,85 @@ class MonitorMetricTypeUtil {
         return "";
     }
   }
+
+  /**
+   * One card per catalog category, in the order an operator walks them
+   * during an incident. When `databaseType` is given, a category whose
+   * metrics are all unsupported on that engine is dropped entirely rather
+   * than rendered as a card of empty charts.
+   */
+  public static getDatabaseMetricCategories(
+    databaseType?: SqlDatabaseType | undefined,
+  ): Array<MonitorMetricCategory> {
+    const supported: Array<MonitorMetricType> | null = databaseType
+      ? getDatabaseMetricsForEngine(databaseType).map(
+          (metric: DatabaseMetricDefinition) => {
+            return metric.metricType;
+          },
+        )
+      : null;
+
+    const categories: Array<MonitorMetricCategory> = [];
+
+    for (const category of getDatabaseMetricCategoryOrder()) {
+      const metrics: Array<MonitorMetricType> = getDatabaseMetricsByCategory(
+        category,
+      )
+        .filter((metric: DatabaseMetricDefinition) => {
+          return !supported || supported.includes(metric.metricType);
+        })
+        .map((metric: DatabaseMetricDefinition) => {
+          return metric.metricType;
+        });
+
+      /*
+       * Availability additionally carries the shared probe series, so it is
+       * never empty even if every catalog metric in it were filtered out.
+       */
+      if (category === DatabaseMetricCategory.Availability) {
+        metrics.unshift(
+          MonitorMetricType.IsOnline,
+          MonitorMetricType.ResponseTime,
+        );
+      }
+
+      if (metrics.length === 0) {
+        continue;
+      }
+
+      categories.push({
+        title: category,
+        description: getDatabaseMetricCategoryDescription(category),
+        metrics: metrics,
+      });
+    }
+
+    return categories;
+  }
+
+  /**
+   * The metric series a criteria filter reads.
+   *
+   * Database Health filters name their series in
+   * databaseMonitorOptions.metricType rather than in the CheckOn itself, so
+   * resolving from the CheckOn alone would return null and silently turn
+   * "evaluate over time" into an instantaneous comparison. Callers that hold
+   * the whole filter - EvaluateOverTime does - must use this instead of
+   * getMonitorMetricTypeByCheckOnOrNull.
+   */
+  public static getMonitorMetricTypeByCriteriaFilterOrNull(
+    criteriaFilter: CriteriaFilter,
+  ): MonitorMetricType | null {
+    if (criteriaFilter.checkOn === CheckOn.DatabaseMetric) {
+      return criteriaFilter.databaseMonitorOptions?.metricType || null;
+    }
+
+    if (criteriaFilter.checkOn === CheckOn.DatabaseIsOnline) {
+      return MonitorMetricType.IsOnline;
+    }
+
+    return this.getMonitorMetricTypeByCheckOnOrNull(criteriaFilter.checkOn);
+  }
 }
 
 export default MonitorMetricTypeUtil;

package/Utils/Monitor/NetworkDeviceRoleCatalog.ts

@@ -0,0 +1,232 @@
+import {
+  NetworkTopologyDeviceRole,
+  NetworkTopologyNode,
+  NetworkTopologyNodeShape,
+} from "../../Types/Monitor/SnmpMonitor/NetworkTopology";
+
+/*
+ * The project's configured device roles, reduced to what the topology needs.
+ *
+ * WHY THIS EXISTS. Roles are rows now (NetworkDeviceRole), which means the
+ * label a role is drawn with, the silhouette it uses, whether it sits at the
+ * core and whether it is worth walking with SNMP are all per-project answers.
+ * None of them can be compiled into the client any more.
+ *
+ * The client is NOT given the table to look things up in, though. The topology
+ * builder stamps the four answers onto each node as it builds it, so every
+ * consumer downstream - the shape module, three layouts, the legend, the
+ * detail panel, the accessible label - keeps its current pure signature and
+ * needs no catalogue threaded through it. This module is the one place that
+ * turns rows into that stamp.
+ *
+ * Pure and dependency-free so it runs identically on the server, in the
+ * builder, and in the unit tests.
+ */
+
+/** One configured role, as the topology builder needs it. */
+export interface TopologyDeviceRoleInput {
+  id?: string | undefined;
+  key: string;
+  name: string;
+  topologyShape?: string | undefined;
+  isCoreLayer?: boolean | undefined;
+  isSnmpWalkable?: boolean | undefined;
+}
+
+/** What gets stamped onto a node. Every field optional - see stampForRoleKey. */
+export interface TopologyNodeRoleStamp {
+  roleId?: string | undefined;
+  roleKey?: string | undefined;
+  roleLabel?: string | undefined;
+  roleShape?: NetworkTopologyNodeShape | undefined;
+  isCoreLayerRole?: boolean | undefined;
+  isSnmpWalkableRole?: boolean | undefined;
+}
+
+/*
+ * The silhouettes the renderer can actually draw. A row's topologyShape is a
+ * free-text column - the geometry lives in the client and adding a shape must
+ * not need a migration - so a value that is not one of these is dropped rather
+ * than passed through to a renderer that would have no path for it.
+ */
+const KNOWN_SHAPES: ReadonlySet<string> = new Set<string>([
+  "circle",
+  "rounded-square",
+  "diamond",
+  "triangle",
+  "hexagon",
+  "tower",
+  "cylinder",
+  "rect",
+]);
+
+export type NormalizeRoleKeyFunction = (
+  value: string | undefined | null,
+) => string | undefined;
+
+/*
+ * Keys are matched case- and whitespace-insensitively, the same way
+ * parseDeviceRoleOverride reads the stored column, so a hand-edited or
+ * imported "Router " still finds the Router row.
+ */
+export const normalizeRoleKey: NormalizeRoleKeyFunction = (
+  value: string | undefined | null,
+): string | undefined => {
+  const normalized: string = (value || "").trim().toLowerCase();
+  return normalized || undefined;
+};
+
+/**
+ * Index the project's roles for lookup by key.
+ *
+ * Later rows do not overwrite earlier ones on a key clash. The key is unique
+ * per project in the database, so a clash here means the caller passed rows
+ * from more than one project, and quietly taking the last one would draw the
+ * wrong project's shapes.
+ */
+export type BuildRoleIndexFunction = (
+  roles: ReadonlyArray<TopologyDeviceRoleInput>,
+) => Map<string, TopologyDeviceRoleInput>;
+
+export const buildDeviceRoleIndex: BuildRoleIndexFunction = (
+  roles: ReadonlyArray<TopologyDeviceRoleInput>,
+): Map<string, TopologyDeviceRoleInput> => {
+  const index: Map<string, TopologyDeviceRoleInput> = new Map<
+    string,
+    TopologyDeviceRoleInput
+  >();
+
+  for (const role of roles) {
+    const key: string | undefined = normalizeRoleKey(role.key);
+    if (!key || index.has(key)) {
+      continue;
+    }
+    index.set(key, role);
+  }
+
+  return index;
+};
+
+export type StampForRoleKeyFunction = (
+  roleKey: string | undefined,
+  index: Map<string, TopologyDeviceRoleInput>,
+) => TopologyNodeRoleStamp;
+
+/**
+ * The stamp for one role key.
+ *
+ * Returns an EMPTY object when the project has no row for the key - which is
+ * the normal case for a project that has not been backfilled yet, and the
+ * permanent case for a project that deleted a seeded role the classifier can
+ * still produce. Every field a node does not get falls back to the built-in
+ * behaviour on the client, so an empty stamp draws exactly the map that was
+ * drawn before roles were configurable.
+ *
+ * The one field always present when a row IS found is `roleKey`, because the
+ * legend groups by it and a group with no key cannot be grouped.
+ */
+export const stampForRoleKey: StampForRoleKeyFunction = (
+  roleKey: string | undefined,
+  index: Map<string, TopologyDeviceRoleInput>,
+): TopologyNodeRoleStamp => {
+  const normalized: string | undefined = normalizeRoleKey(roleKey);
+  if (!normalized) {
+    return {};
+  }
+
+  const role: TopologyDeviceRoleInput | undefined = index.get(normalized);
+  if (!role) {
+    return {};
+  }
+
+  const stamp: TopologyNodeRoleStamp = {
+    roleKey: role.key,
+  };
+
+  if (role.id) {
+    stamp.roleId = role.id;
+  }
+
+  if (role.name) {
+    stamp.roleLabel = role.name;
+  }
+
+  if (role.topologyShape && KNOWN_SHAPES.has(role.topologyShape)) {
+    stamp.roleShape = role.topologyShape as NetworkTopologyNodeShape;
+  }
+
+  if (role.isCoreLayer !== undefined) {
+    stamp.isCoreLayerRole = Boolean(role.isCoreLayer);
+  }
+
+  if (role.isSnmpWalkable !== undefined) {
+    stamp.isSnmpWalkableRole = Boolean(role.isSnmpWalkable);
+  }
+
+  return stamp;
+};
+
+export type RoleKeyForNodeFunction = (
+  assignedRoleKey: string | undefined,
+  classifiedRole: NetworkTopologyDeviceRole,
+) => string | undefined;
+
+/**
+ * Which key a node's presentation should come from.
+ *
+ * The operator's assignment wins, exactly as it does for `role` itself. With
+ * no assignment the classifier's answer is used, so a project that renamed
+ * "Router" to "Edge Router" sees the new name on devices it never had to
+ * touch. "unknown" is not a key any row holds and is deliberately not looked
+ * up: it is the classifier declining to answer, and a neutral node is the
+ * honest drawing of that.
+ */
+export const roleKeyForNode: RoleKeyForNodeFunction = (
+  assignedRoleKey: string | undefined,
+  classifiedRole: NetworkTopologyDeviceRole,
+): string | undefined => {
+  const assigned: string | undefined = normalizeRoleKey(assignedRoleKey);
+  if (assigned) {
+    return assigned;
+  }
+  if (classifiedRole === "unknown") {
+    return undefined;
+  }
+  return classifiedRole;
+};
+
+export type ApplyRoleStampFunction = (
+  node: NetworkTopologyNode,
+  stamp: TopologyNodeRoleStamp,
+) => void;
+
+/**
+ * Copy a stamp onto a node, omitting the fields it does not carry.
+ *
+ * Assigning undefined rather than omitting would break the payload's own
+ * contract - "absent means fall back" - for any consumer that checks with
+ * `in` or serialises the node, so absent stays absent.
+ */
+export const applyRoleStamp: ApplyRoleStampFunction = (
+  node: NetworkTopologyNode,
+  stamp: TopologyNodeRoleStamp,
+): void => {
+  if (stamp.roleId !== undefined) {
+    node.roleId = stamp.roleId;
+  }
+  if (stamp.roleKey !== undefined) {
+    node.roleKey = stamp.roleKey;
+  }
+  if (stamp.roleLabel !== undefined) {
+    node.roleLabel = stamp.roleLabel;
+  }
+  if (stamp.roleShape !== undefined) {
+    node.roleShape = stamp.roleShape;
+  }
+  if (stamp.isCoreLayerRole !== undefined) {
+    node.isCoreLayerRole = stamp.isCoreLayerRole;
+  }
+  if (stamp.isSnmpWalkableRole !== undefined) {
+    node.isSnmpWalkableRole = stamp.isSnmpWalkableRole;
+  }
+};

package/Utils/Monitor/NetworkDeviceRoleUtil.ts

@@ -538,7 +538,8 @@ export function labelForDeviceRole(
  * The classifier above is evidence-driven, and its evidence is SNMP: a
  * device nothing walks — a ping-only device imported by discovery, say —
  * offers it a hostname and nothing else, so it comes back "unknown" and
- * stays there forever. `NetworkDevice.deviceRole` is the operator saying
+ * stays there forever. The role an operator ASSIGNED the device
+ * (NetworkDevice.networkDeviceRole, whose key is what arrives here) is them saying
  * what the box actually is, and it is the only statement about a role that
  * is not an inference, so it outranks everything the classifier can find.
  *