@oneuptime/common 13.0.5 → 13.0.6

package/Server/Services/MonitorProbeService.ts

@@ -14,6 +14,7 @@ import ProbeService from "./ProbeService";
 import { MonitorTypeHelper } from "../../Types/Monitor/MonitorType";
 import CronTab from "../Utils/CronTab";
 import logger, { LogAttributes } from "../Utils/Logger";
+import { SubscriptionStatusUtil } from "../../Types/Billing/SubscriptionStatus";
 
 export class Service extends DatabaseService<MonitorProbe> {
   public constructor() {
@@ -158,7 +159,23 @@ export class Service extends DatabaseService<MonitorProbe> {
          * FOR UPDATE SKIP LOCKED ensures that:
          * 1. Rows are locked for this transaction
          * 2. Rows already locked by other transactions are skipped
+         *
+         * The subscription predicate admits a project with no subscription
+         * (NULL) or one whose status is in
+         * SubscriptionStatusUtil.getActiveSubscriptionStatuses(), bound as $4
+         * rather than spelled out here. This SQL used to carry its own
+         * hand-written active / trialing list, which left out past_due: a
+         * project stopped being probed the moment ONE autopay attempt failed
+         * - including while an India e-mandate card debit was merely still
+         * processing - even though Stripe keeps retrying a past_due invoice
+         * and the dashboard still called the project active. Paying
+         * customers' monitoring was silently switched off. Monitoring now
+         * stops only when the subscription is truly inactive (unpaid,
+         * canceled, incomplete, incomplete_expired, expired, paused).
          */
+        const activeSubscriptionStatuses: Array<string> =
+          SubscriptionStatusUtil.getActiveSubscriptionStatuses();
+
         const selectQuery: string = `
         SELECT mp."_id", m."monitoringInterval"
         FROM "MonitorProbe" mp
@@ -174,9 +191,9 @@ export class Service extends DatabaseService<MonitorProbe> {
           AND m."deletedAt" IS NULL
           AND p."deletedAt" IS NULL
           AND (p."paymentProviderSubscriptionStatus" IS NULL
-               OR p."paymentProviderSubscriptionStatus" IN ('active', 'trialing'))
+               OR p."paymentProviderSubscriptionStatus" = ANY($4::text[]))
           AND (p."paymentProviderMeteredSubscriptionStatus" IS NULL
-               OR p."paymentProviderMeteredSubscriptionStatus" IN ('active', 'trialing'))
+               OR p."paymentProviderMeteredSubscriptionStatus" = ANY($4::text[]))
         ORDER BY mp."nextPingAt" ASC NULLS FIRST
         LIMIT $3
         FOR UPDATE OF mp SKIP LOCKED
@@ -189,6 +206,7 @@ export class Service extends DatabaseService<MonitorProbe> {
           data.probeId.toString(),
           currentDate,
           data.limit,
+          activeSubscriptionStatuses,
         ]);
 
         if (selectedRows.length === 0) {

package/Server/Services/MonitorService.ts

@@ -1265,14 +1265,16 @@ export class Service extends DatabaseService<Model> {
     }
 
     /*
-     * Labels decide SLO membership, so a label added or removed here can pull
-     * this monitor into an SLO's error budget or push it out of one. Keyed on
-     * `!== undefined` rather than on a non-empty array: clearing every label
-     * arrives as `[]`, and that is precisely the edit that should detach the
-     * monitor from every rule-driven SLO.
+     * SLO monitor rules match on labels, name and description, so an edit to
+     * any of the three can pull this monitor into an SLO's error budget or
+     * push it out of one. Keyed on `!== undefined` rather than on a non-empty
+     * value: clearing every label arrives as `[]`, and that is precisely the
+     * edit that should detach the monitor from every rule-driven SLO.
      */
     if (
-      onUpdate.updateBy.data.labels !== undefined &&
+      (onUpdate.updateBy.data.labels !== undefined ||
+        onUpdate.updateBy.data.name !== undefined ||
+        onUpdate.updateBy.data.description !== undefined) &&
       updatedItemIds.length > 0
     ) {
       for (const monitorId of updatedItemIds) {
@@ -1285,7 +1287,7 @@ export class Service extends DatabaseService<Model> {
           );
         } catch (error) {
           logger.error(
-            "Syncing SLO label rules failed in MonitorService.onUpdateSuccess",
+            "Syncing SLO monitor rules failed in MonitorService.onUpdateSuccess",
             {
               monitorId: monitorId?.toString(),
             } as LogAttributes,
@@ -1765,7 +1767,7 @@ ${createdItem.description?.trim() || "No description provided."}
         /*
          * Runs after the label rules above so a monitor created with no labels
          * of its own, but given some by a MonitorLabelRule, still lands in the
-         * SLOs those labels imply.
+         * SLOs whose monitor rules those labels satisfy.
          */
         try {
           await ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor(
@@ -1776,7 +1778,7 @@ ${createdItem.description?.trim() || "No description provided."}
           );
         } catch (error) {
           logger.error(
-            "Syncing SLO label rules failed in MonitorService.onCreateSuccess",
+            "Syncing SLO monitor rules failed in MonitorService.onCreateSuccess",
             {
               projectId: createdItem.projectId?.toString(),
               monitorId: createdItem.id?.toString(),

package/Server/Services/NetworkDeviceAutoImportRuleEngineService.ts

@@ -33,7 +33,16 @@ import {
   buildNetworkDeviceFromDiscoveredHost,
 } from "../../Utils/NetworkDiscovery/DiscoveredDeviceBuilder";
 import { normalizeDiscoveredHosts } from "../../Utils/NetworkDiscovery/DiscoveredHostUtil";
-import { DISCOVERY_SCAN_IMPORTABLE_STATUSES } from "../../Utils/NetworkDiscovery/DiscoveryScanStatus";
+import {
+  DISCOVERY_SCAN_IMPORTABLE_STATUSES,
+  DiscoveryScanStatus,
+} from "../../Utils/NetworkDiscovery/DiscoveryScanStatus";
+import {
+  RunImportedDeviceRename,
+  RunImportedDeviceRow,
+  getNamedHostsByAddress,
+  planRunImportedDeviceRenames,
+} from "../../Utils/NetworkDiscovery/RunImportedDeviceNaming";
 import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 import NetworkDeviceMonitorTemplateUtil from "../../Utils/Monitor/NetworkDeviceMonitorTemplateUtil";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
@@ -101,6 +110,31 @@ export const AUTO_IMPORT_SCAN_CREDENTIAL_SELECT: {
   snmpV3PrivKey: true,
 };
 
+/*
+ * Every scan column the device builder reads — the credentials above, plus
+ * the scan's naming choice (issue #3678). Both engine reads of a scan select
+ * THIS, never the credential list alone.
+ *
+ * Kept as a superset rather than folded into the credential select because
+ * the two answer different questions. The credential select is pinned key for
+ * key against what the probe claim endpoint sweeps with
+ * (AutoImportScanCredentialSelect.test.ts): a credential the probe uses and
+ * the device lacks is a device that can never poll. `useShortDeviceNames`
+ * decides nothing about the sweep, so the probe has no business being handed
+ * it — but the builder does read it, and an unselected column arrives
+ * undefined, which the builder reads as "off". A scan that asked for short
+ * names would then import every host under its full FQDN, silently, on the
+ * one path where nobody reviews the result. Same failure mode as a dropped
+ * credential, one column over, which is why the same test pins this set
+ * against the builder's DiscoveredDeviceScanSource.
+ */
+export const AUTO_IMPORT_SCAN_BUILDER_SELECT: {
+  [key: string]: boolean;
+} = {
+  ...AUTO_IMPORT_SCAN_CREDENTIAL_SELECT,
+  useShortDeviceNames: true,
+};
+
 /*
  * Devices one pass will create from one scan. Deliberately conservative:
  * every create runs the full service pipeline plus a detached
@@ -164,6 +198,29 @@ export const MAX_CONSECUTIVE_MONITOR_CREATE_FAILURES: number = 10;
  */
 export const MAX_RESULT_AGE_IN_HOURS: number = 24;
 
+/*
+ * Devices one pass will rename after a Completed result names what the run
+ * imported by address (see renameDevicesImportedDuringRun). Every rename is a
+ * full update pipeline — a site-assignment re-evaluation among other things —
+ * plus up to two name-collision counts, so an unbounded pass over a /16 that
+ * was imported mid-sweep would be tens of thousands of writes inside one
+ * worker tick. Higher than the create cap because an update is a fraction of
+ * a create's work. What the cap leaves over is logged, not retried: the
+ * result is stamped processed as usual, and those devices keep their address
+ * names until someone renames them.
+ */
+export const MAX_DEVICE_RENAMES_PER_SCAN_PASS: number = 2000;
+
+/*
+ * Addresses per "which devices this run imported sit at these addresses"
+ * query — the same bound, for the same reason, as NetworkDeviceService's
+ * HOSTNAME_LOOKUP_CHUNK_SIZE: the list is rendered into the statement as a
+ * literal IN. Kept as its own constant rather than imported so a module-level
+ * service mock in a test cannot turn it into undefined and the loop into a
+ * single empty chunk.
+ */
+export const RUN_IMPORTED_DEVICE_LOOKUP_CHUNK_SIZE: number = 500;
+
 /*
  * The Redis lock every path that CREATES devices from scan results runs
  * under — the worker sweep and the manual Run Now alike. The engine's
@@ -297,8 +354,15 @@ class NetworkDeviceAutoImportRuleEngineServiceClass {
           scannedHostCount: true,
           respondedHostCount: true,
           autoImportProcessedAt: true,
+          /*
+           * When this run was claimed — the line renameDevicesImportedDuringRun
+           * draws between devices this run imported and devices that were
+           * already there.
+           */
+          startedAt: true,
           discoveredDevices: true,
-          ...AUTO_IMPORT_SCAN_CREDENTIAL_SELECT,
+          // Credentials AND naming — see AUTO_IMPORT_SCAN_BUILDER_SELECT.
+          ...AUTO_IMPORT_SCAN_BUILDER_SELECT,
         },
         props: {
           isRoot: true,
@@ -322,6 +386,41 @@ class NetworkDeviceAutoImportRuleEngineServiceClass {
 
     const projectId: ObjectID = scan.projectId;
 
+    /*
+     * Decided once, up front, because two steps below depend on it and must
+     * agree: the renames (which an old result must not trigger) and the
+     * too-old early exit itself.
+     */
+    const isTooOldToAutoImport: boolean = this.isTooOldToAutoImport(scan);
+
+    /*
+     * Name what this run imported by address before its names were known
+     * (issue #3677) — see renameDevicesImportedDuringRun.
+     *
+     * Placed here, ahead of both early exits below, and gated on the age check
+     * by hand. It has to run BEFORE the "no import rules" exit, because the
+     * devices it fixes are just as often the ones an operator imported from
+     * the Review dialog while the scan was still sweeping, in a project with
+     * no rules at all. And it must NOT run for a result that is too old to
+     * auto-import: that guard exists so a late or backlogged result never
+     * makes surprising changes to the estate, and a wave of renames is such a
+     * change. The two exits used to be ordered "no rules" then "too old" and
+     * still are, so a rule-less project stamps an old result without the
+     * too-old warning it has never logged.
+     *
+     * Also ahead of the import: the import re-reads the devices at these
+     * addresses, so a monitor provisioned onto one of them in this same pass
+     * is built from the device's new name rather than its address.
+     *
+     * Runs once per result, because this path runs once per result: the
+     * result is stamped processed below. A pass that leaves the marker NULL to
+     * resume a capped import runs it again next tick, which finds nothing
+     * left to rename. The step never throws.
+     */
+    if (!isTooOldToAutoImport) {
+      await this.renameDevicesImportedDuringRun({ scan: scan });
+    }
+
     const rules: Array<NetworkDeviceAutoImportRule> =
       await this.loadEnabledRules(projectId);
 
@@ -337,7 +436,7 @@ class NetworkDeviceAutoImportRuleEngineServiceClass {
       return null;
     }
 
-    if (this.isTooOldToAutoImport(scan)) {
+    if (isTooOldToAutoImport) {
       logger.warn(
         `Auto-import: scan ${scan.id?.toString()} completed more than ${MAX_RESULT_AGE_IN_HOURS} hours ago; stamping it processed without importing. Use the rule's Run Now to import old results deliberately.`,
         { projectId: projectId.toString() } as LogAttributes,
@@ -785,7 +884,13 @@ class NetworkDeviceAutoImportRuleEngineServiceClass {
             scannedHostCount: true,
             respondedHostCount: true,
             discoveredDevices: true,
-            ...AUTO_IMPORT_SCAN_CREDENTIAL_SELECT,
+            /*
+             * The same builder select as the automatic path, so a dry run
+             * previews — and a real run imports — the names the scan asked
+             * for, not the full FQDNs an unselected naming column falls
+             * back to.
+             */
+            ...AUTO_IMPORT_SCAN_BUILDER_SELECT,
           },
           // Preserve the raw scan rows for the compare-and-set write-back.
           props: { isRoot: true, ignoreHooks: true },
@@ -986,6 +1091,262 @@ class NetworkDeviceAutoImportRuleEngineServiceClass {
     return rules;
   }
 
+  /*
+   * Rename the devices this scan's run imported by their bare address, now
+   * that its Completed result carries the names it resolved (part of OneUptime
+   * issue #3677).
+   *
+   * THE BUG. Auto-import consumes a running sweep's partial snapshots
+   * (DISCOVERY_SCAN_IMPORTABLE_STATUSES), and a partial snapshot never
+   * carries reverse-DNS names: the probe resolves them once, after the sweep
+   * (Probe/Utils/Discovery/SubnetScanner.ts), and only the final upload has
+   * them. So a host without an SNMP sysName is imported mid-run named by its
+   * address. When the final result lands with "kds01.wbhq.com" on that
+   * host's row, importHostsFromScan skips the host — its address is already
+   * registered, which is the idempotency the engine is built on — and the
+   * device keeps its address as its name forever. An operator importing from
+   * the Review dialog while the scan is running hits the same thing.
+   *
+   * WHAT IS RENAMED is decided by planRunImportedDeviceRenames, whose header
+   * explains each condition. The one that matters most for an upgrade: only
+   * devices CREATED DURING THIS RUN (createdAt >= the scan's startedAt). A
+   * long-standing device someone deliberately named by its address, or one
+   * imported before reverse DNS existed, is not this bug, and renaming all of
+   * those on the first scan after an upgrade would be a silent mass edit on
+   * the one path nobody reviews. A scan with no startedAt renames nothing.
+   *
+   * Only for a scan whose status is exactly Completed. An In Progress scan's
+   * rows have no names yet by construction, and a Failed scan never reaches
+   * this path (it is not importable); checking the status here rather than
+   * trusting the caller keeps a future change to the importable statuses
+   * from turning this on for results that cannot name anything.
+   *
+   * WHAT A RENAME IS. The name the import would have chosen had it waited
+   * (buildDeviceName under the scan's naming choice), or the import's own
+   * address-suffixed fallback when another device already has that name,
+   * or nothing when both are taken — the import's collision protocol, with
+   * the same case-insensitive check the create-time uniqueness guard runs
+   * (DatabaseService.checkUniqueColumnBy), because an update does not enforce
+   * name uniqueness and so this has to. Names taken earlier in this same pass
+   * count as taken. The PTR name is filled into dnsName when the device has
+   * none, as the builder would have at create. The write goes through
+   * updateOneById so the normal update hooks run: a name is an identity
+   * column for site-assignment rules, and re-evaluating them on the new name
+   * is exactly what should happen.
+   *
+   * Never throws. A failed lookup or write is logged per device and the rest
+   * carry on, and a failure of the step as a whole is logged and swallowed:
+   * a device left named by its address is a cosmetic fault, and must not
+   * cost the scan its import or its processed stamp.
+   *
+   * Returns how many devices were renamed.
+   */
+  private async renameDevicesImportedDuringRun(data: {
+    scan: NetworkDeviceDiscoveryScan;
+  }): Promise<number> {
+    const scan: NetworkDeviceDiscoveryScan = data.scan;
+
+    if (scan.status !== DiscoveryScanStatus.Completed) {
+      return 0;
+    }
+
+    if (!scan.projectId || !scan.startedAt || !scan.completedAt) {
+      return 0;
+    }
+
+    const projectId: ObjectID = scan.projectId;
+    const logAttributes: LogAttributes = {
+      projectId: projectId.toString(),
+    } as LogAttributes;
+
+    try {
+      const runStartedAt: Date = OneUptimeDate.fromString(scan.startedAt);
+
+      if (Number.isNaN(runStartedAt.getTime())) {
+        return 0;
+      }
+
+      const namedHostAddresses: Array<string> = Array.from(
+        getNamedHostsByAddress(scan.discoveredDevices, scan).keys(),
+      );
+
+      if (namedHostAddresses.length === 0) {
+        return 0;
+      }
+
+      const rows: Array<RunImportedDeviceRow> = [];
+
+      for (
+        let offset: number = 0;
+        offset < namedHostAddresses.length;
+        offset += RUN_IMPORTED_DEVICE_LOOKUP_CHUNK_SIZE
+      ) {
+        const chunk: Array<string> = namedHostAddresses.slice(
+          offset,
+          offset + RUN_IMPORTED_DEVICE_LOOKUP_CHUNK_SIZE,
+        );
+
+        const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy(
+          {
+            query: {
+              projectId: projectId,
+              hostname: QueryHelper.any(chunk),
+              /*
+               * Condition (d) in the query too, so an established estate
+               * returns no rows here rather than every device the scan
+               * re-reported. The planner checks it again regardless.
+               */
+              createdAt: QueryHelper.greaterThanEqualTo(runStartedAt),
+            },
+            select: {
+              _id: true,
+              projectId: true,
+              name: true,
+              hostname: true,
+              dnsName: true,
+              createdAt: true,
+            },
+            sort: {},
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: { isRoot: true },
+          },
+        );
+
+        for (const device of devices) {
+          if (!device.id) {
+            continue;
+          }
+
+          rows.push({
+            deviceId: device.id.toString(),
+            projectId: device.projectId?.toString(),
+            name: device.name,
+            hostname: device.hostname,
+            dnsName: device.dnsName,
+            createdAt: device.createdAt,
+          });
+        }
+      }
+
+      const plans: Array<RunImportedDeviceRename> =
+        planRunImportedDeviceRenames({
+          projectId: projectId.toString(),
+          hosts: scan.discoveredDevices,
+          devices: rows,
+          scan: scan,
+          runStartedAt: runStartedAt,
+          runCompletedAt: scan.completedAt,
+        });
+
+      // Lower-cased names this pass has already given to a device.
+      const namesTakenThisPass: Set<string> = new Set<string>();
+      let renamedCount: number = 0;
+      let attemptedCount: number = 0;
+      let skippedCount: number = 0;
+
+      for (let index: number = 0; index < plans.length; index++) {
+        const plan: RunImportedDeviceRename = plans[index]!;
+
+        if (attemptedCount >= MAX_DEVICE_RENAMES_PER_SCAN_PASS) {
+          logger.warn(
+            `Auto-import: scan ${scan.id?.toString()} reached the cap of ${MAX_DEVICE_RENAMES_PER_SCAN_PASS} device renames in one pass; ${plans.length - index} device(s) imported during its run keep their address as their name. Rename them from the Devices list.`,
+            logAttributes,
+          );
+          break;
+        }
+
+        try {
+          const newName: string | null = await this.pickFreeDeviceName({
+            projectId: projectId,
+            candidateNames: plan.candidateNames,
+            namesTakenThisPass: namesTakenThisPass,
+          });
+
+          if (!newName) {
+            skippedCount++;
+            logger.debug(
+              `Auto-import: not renaming Network Device ${plan.deviceId} (${plan.hostname}); every name it could take (${plan.candidateNames.join(", ")}) already belongs to another device.`,
+              logAttributes,
+            );
+            continue;
+          }
+
+          attemptedCount++;
+
+          const update: JSONObject = { name: newName };
+
+          if (plan.dnsName) {
+            update["dnsName"] = plan.dnsName;
+          }
+
+          await NetworkDeviceService.updateOneById({
+            id: new ObjectID(plan.deviceId),
+            data: update as unknown as QueryDeepPartialEntity<NetworkDevice>,
+            props: { isRoot: true },
+          });
+
+          namesTakenThisPass.add(newName.toLowerCase());
+          renamedCount++;
+        } catch (error) {
+          logger.error(
+            `Auto-import: could not rename Network Device ${plan.deviceId} (${plan.hostname}) after scan ${scan.id?.toString()} resolved its name: ${error}`,
+            logAttributes,
+          );
+        }
+      }
+
+      if (renamedCount > 0 || skippedCount > 0) {
+        logger.info(
+          `Auto-import: scan ${scan.id?.toString()} named ${renamedCount} device(s) that its run had imported by address before their names were resolved${skippedCount > 0 ? `; ${skippedCount} kept their address because every name they could take was already in use` : ""}.`,
+          logAttributes,
+        );
+      }
+
+      return renamedCount;
+    } catch (error) {
+      logger.error(
+        `Auto-import: could not rename the devices scan ${scan.id?.toString()} imported by address during its run; continuing with the import: ${error}`,
+        logAttributes,
+      );
+      return 0;
+    }
+  }
+
+  /*
+   * The first candidate no device in the project already holds — compared
+   * the way DatabaseService.checkUniqueColumnBy compares at create
+   * (case-insensitive, trimmed), and counting names this pass has already
+   * handed out, which the database may not show yet. Null when all are taken.
+   */
+  private async pickFreeDeviceName(data: {
+    projectId: ObjectID;
+    candidateNames: Array<string>;
+    namesTakenThisPass: Set<string>;
+  }): Promise<string | null> {
+    for (const candidate of data.candidateNames) {
+      if (data.namesTakenThisPass.has(candidate.toLowerCase())) {
+        continue;
+      }
+
+      const holders: number = (
+        await NetworkDeviceService.countBy({
+          query: {
+            projectId: data.projectId,
+            name: QueryHelper.findWithSameText(candidate),
+          },
+          props: { isRoot: true },
+        })
+      ).toNumber();
+
+      if (holders === 0) {
+        return candidate;
+      }
+    }
+
+    return null;
+  }
+
   private isTooOldToAutoImport(scan: NetworkDeviceDiscoveryScan): boolean {
     if (!scan.completedAt) {
       return false;
@@ -2017,7 +2378,17 @@ class NetworkDeviceAutoImportRuleEngineServiceClass {
       }
 
       try {
-        createdDevice = await attemptCreate(buildFallbackDeviceName(data.host));
+        /*
+         * Named under the SAME naming choice as the first attempt. The
+         * fallback is the first attempt's name plus the address, so a scan
+         * with short names on retries "web (10.0.0.5)" — not
+         * "web.corp.example.com (10.0.0.5)", which would be a device named by
+         * the FQDN the operator asked to drop, and only for the hosts that
+         * happened to collide.
+         */
+        createdDevice = await attemptCreate(
+          buildFallbackDeviceName(data.host, data.scan),
+        );
       } catch (secondError) {
         data.result.devicesFailed++;
         this.recordFailureReason(data.result.deviceFailureReasons, secondError);