@oneuptime/common 13.0.5 → 13.0.7

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -2,6 +2,7 @@ import logger from "../../../Utils/Logger";
 import {
   CheckOn,
   CriteriaFilter,
+  CriteriaFilterUtil,
   EvaluateOverTimeType,
   FilterType,
 } from "../../../../Types/Monitor/CriteriaFilter";
@@ -477,8 +478,8 @@ export default class CompareCriteria {
     unit?: string | undefined;
     /**
      * The metric NAME, when there is a real one. Distinct from
-     * metricDisplayName, which is the formula expression for a formula
-     * criteria and is only ever used as a label: this one feeds
+     * metricDisplayName, which is only a label (a configured title or a
+     * formula expression). This one feeds
      * ValueFormatter.isFractionMetric, which would read the trailing
      * `_ratio` of a formula like `a / b_ratio` as a signal to multiply
      * the value by 100. Callers pass it only for plain metric criteria.
@@ -643,20 +644,22 @@ export default class CompareCriteria {
     unit?: string | undefined;
     /**
      * The metric NAME, when there is a real one. Distinct from
-     * metricDisplayName, which is the formula expression for a formula
-     * criteria and is only ever used as a label: this one feeds
+     * metricDisplayName, which is only a label (a configured title or a
+     * formula expression). This one feeds
      * ValueFormatter.isFractionMetric, which would read the trailing
      * `_ratio` of a formula like `a / b_ratio` as a signal to multiply
      * the value by 100. Callers pass it only for plain metric criteria.
      */
     metricName?: string | undefined;
   }): string {
-    // CPU Percent over the last 5 minutes is 10 which is less than the threshold of 20
     let message: string = "";
-    let breachSummary: string = "";
 
+    /*
+     * Name the type the window was judged with. A boolean series saved with
+     * an aggregate is judged as All Values, so it must not read as an average.
+     */
     let evaluationType: EvaluateOverTimeType | undefined =
-      data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType;
+      CriteriaFilterUtil.getEffectiveEvaluateOverTimeType(data.criteriaFilter);
 
     if (data.criteriaFilter.metricMonitorOptions?.metricAggregationType) {
       evaluationType =
@@ -697,48 +700,34 @@ export default class CompareCriteria {
      * Prefer a metric-specific display name over the generic "Metric Value"
      * label when evaluating metric monitors.
      */
-    const label: string =
+    let label: string =
       data.metricDisplayName &&
       data.criteriaFilter.checkOn === CheckOn.MetricValue
         ? data.metricDisplayName
         : data.criteriaFilter.checkOn;
 
-    message += ` ${label}`;
-
     if (data.criteriaFilter.checkOn === CheckOn.DiskUsagePercent) {
       const diskPath: string =
         data.criteriaFilter.serverMonitorOptions?.diskPath || "/";
 
-      message += ` on disk ${diskPath}`;
+      label += ` on disk ${diskPath}`;
     }
 
     if (
       data.criteriaFilter.evaluateOverTime &&
       data.criteriaFilter.evaluateOverTimeOptions?.timeValueInMinutes
     ) {
-      message += ` over the last ${data.criteriaFilter.evaluateOverTimeOptions.timeValueInMinutes} minutes`;
+      const minutes: number =
+        data.criteriaFilter.evaluateOverTimeOptions.timeValueInMinutes;
+      label += ` over the last ${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
     }
 
+    message += ` ${label}`;
+
     /*
-     * A metric value is written the way the dashboard writes it —
-     * "1.07 GB", "1.5 sec", "25.34%" — rather than as raw digits with a
-     * raw UCUM code glued on. Only two of the ~35 callers pass a unit at
-     * all (MetricMonitorCriteria and DatabaseMonitorCriteria); everything
-     * else carries its unit inside the CheckOn label ("Response Time (in
-     * ms)") and must keep its exact digits, so an absent unit leaves this
-     * sentence byte-for-byte as it was.
-     *
-     * MetricValueFormatter also subsumes the unit-suppression rules this
-     * block used to spell out by hand: OTel's dimensionless "1" (which
-     * made a CLS breach read "is 0.31 1 which is greater than or equal to
-     * 0.25 1") and UCUM's annotation-only "{cpu}" / "{packets}" both
-     * disappear, and a fraction metric still carrying "1" is rendered as
-     * the percentage it means.
-     *
-     * The unit rides each NUMBER instead of the sentence, because
-     * auto-scaling can land two samples in the same sentence on different
-     * scales — "is 900 KB, 1.2 MB" — which one trailing suffix cannot
-     * express.
+     * Format each number in its own unit and scale, including the threshold
+     * and both ends of a range. Keep the original precision when no unit is
+     * available; metric-name hints apply only to plain metrics, not formulas.
      */
     const withUnit: ((value: number) => string) | undefined =
       MetricValueFormatter.hasDisplayableUnit(data.unit, data.metricName)
@@ -751,62 +740,48 @@ export default class CompareCriteria {
           }
         : undefined;
 
+    const numericValues: Array<number | boolean> = Array.isArray(data.values)
+      ? data.values
+      : typeof data.values === "number"
+        ? [data.values]
+        : [];
+
+    if (
+      typeof data.threshold === "number" &&
+      Number.isFinite(data.threshold) &&
+      numericValues.length > 0 &&
+      numericValues.every((value: number | boolean) => {
+        return typeof value === "number" && Number.isFinite(value);
+      })
+    ) {
+      const numericMessage: string | null =
+        CompareCriteria.getNumericCompareMessage({
+          values: numericValues as Array<number>,
+          isSeries: Array.isArray(data.values),
+          threshold: data.threshold,
+          filterType: data.criteriaFilter.filterType as FilterType,
+          // Use the same precedence as compareCriteriaNumbers.
+          evaluationType:
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
+          label,
+          withUnit,
+        });
+
+      if (numericMessage !== null) {
+        return numericMessage;
+      }
+    }
+
     if (
       data.criteriaFilter.filterType !== FilterType.True &&
       data.criteriaFilter.filterType !== FilterType.False
     ) {
-      /*
-       * Print the samples that actually breached, not the whole window.
-       *
-       * `AnyValue` is an existential quantifier: it is met when ONE sample
-       * crosses the threshold. Printing the entire window and then
-       * asserting "which is greater than 90" produced the sentence a real
-       * customer received — "is 72.35, 81.54, 79.95, 91.53, 87.73 % which
-       * is greater than 90 %" — in which four of the five listed numbers
-       * are below the threshold the sentence claims they all exceed.
-       *
-       * For every other evaluation type the reported set and the compared
-       * set are the same thing (a reducing aggregation collapses to one
-       * value; AllValues requires all of them), so this narrowing is a
-       * no-op and the existing wording is preserved exactly.
-       */
-      const reportedValues:
-        | Array<number | boolean>
-        | number
-        | boolean
-        | string = CompareCriteria.getReportedValues({
-        values: data.values,
-        threshold: data.threshold,
-        filterType: data.criteriaFilter.filterType as FilterType,
-        evaluationType: evaluationType,
-      });
-
       const formattedValues: string = CompareCriteria.formatCriteriaValues(
-        reportedValues,
+        data.values,
         withUnit,
       );
-
-      message += ` is ${formattedValues}`;
-
-      message += " which is";
-
-      /*
-       * How much of the window actually breached.
-       *
-       * Without it "Any value ... is 91.53 % which is greater than 90 %"
-       * is true but hides the thing the reader needs in order to judge
-       * whether to get out of bed: whether that was one transient sample
-       * or the whole five minutes. One-in-five is a spike; five-in-five is
-       * an outage. Only added when the two counts differ, so a fully
-       * breaching window keeps the shorter sentence.
-       */
-      if (
-        Array.isArray(data.values) &&
-        Array.isArray(reportedValues) &&
-        reportedValues.length < data.values.length
-      ) {
-        breachSummary = ` ${reportedValues.length} of ${data.values.length} samples in the evaluation window breached this threshold.`;
-      }
+      message += ` is ${formattedValues} which is`;
     }
 
     switch (data.criteriaFilter.filterType) {
@@ -848,65 +823,106 @@ export default class CompareCriteria {
         break;
     }
 
-    return `${message.trim()}${breachSummary}`;
+    return message.trim();
   }
 
-  /*
-   * Narrow the window down to what the message should quote.
-   *
-   * Only `AnyValue` needs narrowing — see the comment at the call site.
-   * A reducing aggregation is collapsed to its single aggregate so the
-   * sentence quotes the average it actually compared, not the raw samples.
-   * If nothing is found to breach (a caller rendering a message for a
-   * filter that did not match, or a non-numeric window) the original
-   * values are returned unchanged rather than an empty list, so the
-   * message degrades to its previous behaviour instead of to "is ".
-   */
-  private static getReportedValues(data: {
-    values: Array<number | boolean> | number | boolean | string;
-    threshold: number | string | boolean;
+  private static getNumericCompareMessage(data: {
+    values: Array<number>;
+    isSeries: boolean;
+    threshold: number;
     filterType: FilterType;
-    evaluationType?: EvaluateOverTimeType | undefined;
-  }): Array<number | boolean> | number | boolean | string {
-    if (!Array.isArray(data.values)) {
-      return data.values;
-    }
-
-    if (typeof data.threshold !== Typeof.Number) {
-      return data.values;
-    }
-
-    const numericValues: Array<number> = data.values.filter(
-      (value: number | boolean): value is number => {
-        return typeof value === Typeof.Number && Number.isFinite(value);
-      },
-    );
-
-    if (numericValues.length !== data.values.length) {
-      return data.values;
-    }
-
+    evaluationType: EvaluateOverTimeType | undefined;
+    label: string;
+    withUnit: ((value: number) => string) | undefined;
+  }): string | null {
+    const relations: Partial<Record<FilterType, string>> = {
+      [FilterType.GreaterThan]: "above",
+      [FilterType.GreaterThanOrEqualTo]: "at or above",
+      [FilterType.LessThan]: "below",
+      [FilterType.LessThanOrEqualTo]: "at or below",
+      [FilterType.EqualTo]: "equal to",
+      [FilterType.NotEqualTo]: "different from",
+    };
+    const relation: string | undefined = relations[data.filterType];
     const predicate: ((value: number) => boolean) | null =
-      CompareCriteria.getNumericPredicate({
-        filterType: data.filterType,
-        threshold: data.threshold as number,
-      });
+      CompareCriteria.getNumericPredicate(data);
 
-    if (!predicate) {
-      return data.values;
+    if (!relation || !predicate) {
+      return null;
     }
 
-    const breaching: Array<number> = CompareCriteria.getBreachingValues({
-      values: numericValues,
+    const aggregations: Partial<Record<EvaluateOverTimeType, string>> = {
+      [EvaluateOverTimeType.Average]: "average",
+      [EvaluateOverTimeType.Sum]: "sum",
+      [EvaluateOverTimeType.MaximumValue]: "maximum",
+      [EvaluateOverTimeType.MunimumValue]: "minimum",
+    };
+    const aggregation: string | undefined = data.evaluationType
+      ? aggregations[data.evaluationType]
+      : undefined;
+    const reducedValues: Array<number> = CompareCriteria.reduceWindow({
+      values: data.values,
       evaluationType: data.evaluationType,
-      predicate: predicate,
     });
+    const matchingValues: Array<number> = reducedValues.filter(predicate);
+    const reportedValues: Array<number> =
+      data.evaluationType === EvaluateOverTimeType.AnyValue &&
+      matchingValues.length > 0
+        ? matchingValues
+        : reducedValues;
+
+    // Avoid listing repeated readings or unbounded windows in notifications.
+    let minimum: number = reportedValues[0]!;
+    let maximum: number = reportedValues[0]!;
+    for (const value of reportedValues) {
+      minimum = Math.min(minimum, value);
+      maximum = Math.max(maximum, value);
+    }
+    const low: string = CompareCriteria.formatSingleValue(
+      minimum,
+      data.withUnit,
+    );
+    const high: string = CompareCriteria.formatSingleValue(
+      maximum,
+      data.withUnit,
+    );
+    const subject: string = aggregation
+      ? `The ${aggregation} of ${data.label}`
+      : data.label;
+    let observation: string =
+      low === high
+        ? `${subject} was ${low}`
+        : `${subject} ranged from ${low} to ${high}`;
+
+    if (data.isSeries && !aggregation) {
+      let readings: string = "1 reading";
+      if (reportedValues.length < data.values.length) {
+        readings = `${reportedValues.length} of ${data.values.length} readings`;
+      } else if (data.values.length > 1) {
+        readings = `all ${data.values.length} readings`;
+      }
+      observation += ` ${low === high ? "in" : "across"} ${readings}`;
+    }
 
-    if (breaching.length === 0) {
-      return data.values;
+    const comparison: string = `${relation} the ${CompareCriteria.formatSingleValue(data.threshold, data.withUnit)} threshold`;
+    const matches: boolean =
+      data.evaluationType === EvaluateOverTimeType.AnyValue
+        ? matchingValues.length > 0
+        : matchingValues.length === reducedValues.length;
+
+    if (!matches) {
+      // Direct callers can request a description even when a filter did not match.
+      const requirement: string = aggregation
+        ? `the ${aggregation}`
+        : !data.isSeries
+          ? "the value"
+          : data.evaluationType === EvaluateOverTimeType.AnyValue
+            ? "at least one reading"
+            : "every reading";
+      return `${observation}. The condition requires ${requirement} to be ${comparison}.`;
     }
 
-    return breaching;
+    return `${observation}, ${comparison}.`;
   }
 
   /*

package/Server/Utils/Monitor/Criteria/EvaluateOverTime.ts

@@ -3,8 +3,8 @@ import { LIMIT_PER_PROJECT } from "../../../../Types/Database/LimitMax";
 import OneUptimeDate from "../../../../Types/Date";
 import { JSONObject } from "../../../../Types/JSON";
 import {
-  CheckOn,
   CriteriaFilter,
+  CriteriaFilterUtil,
   EvaluateOverTimeOptions,
   EvaluateOverTimeType,
   NoDataPolicy,
@@ -170,19 +170,13 @@ export default class EvaluateOverTime {
     if (policy === NoDataPolicy.TreatAsZero) {
       /*
        * Zero for numeric series, and its boolean equivalent (false) for the
-       * online/timeout series, which EvaluateOverTime already maps 1 -> true.
+       * boolean series, whose samples evaluateOverTime maps 1 -> true.
        */
-      const isBooleanSeries: boolean =
-        data.criteriaFilter.checkOn === CheckOn.IsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.IsRequestTimeout ||
-        data.criteriaFilter.checkOn === CheckOn.DnsIsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.SnmpIsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.DatabaseIsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.ExternalStatusPageIsOnline;
-
       return {
         earlyReturn: null,
-        value: isBooleanSeries ? [false] : [0],
+        value: CriteriaFilterUtil.isBooleanSeries(data.criteriaFilter.checkOn)
+          ? [false]
+          : [0],
       };
     }
 
@@ -308,6 +302,18 @@ export default class EvaluateOverTime {
       };
     }
 
+    const isBooleanSeries: boolean = CriteriaFilterUtil.isBooleanSeries(
+      data.criteriaFilter.checkOn,
+    );
+
+    /*
+     * A boolean series saved with Average / Sum / Maximum / Minimum is judged
+     * as All Values. Reducing it would hand the True / False comparators a
+     * number such as 0.6, which matches neither, so the filter never fired.
+     */
+    const evaluateOverTimeType: EvaluateOverTimeType | undefined =
+      CriteriaFilterUtil.getEffectiveEvaluateOverTimeType(data.criteriaFilter);
+
     const sampleTimes: Array<Date> = [];
 
     const values: Array<number | boolean> = [];
@@ -317,13 +323,7 @@ export default class EvaluateOverTime {
         continue;
       }
 
-      if (
-        data.criteriaFilter.checkOn === CheckOn.IsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.IsRequestTimeout ||
-        data.criteriaFilter.checkOn === CheckOn.DnsIsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.SnmpIsOnline ||
-        data.criteriaFilter.checkOn === CheckOn.ExternalStatusPageIsOnline
-      ) {
+      if (isBooleanSeries) {
         values.push(item.value === 1);
       } else {
         values.push(item.value);
@@ -355,10 +355,7 @@ export default class EvaluateOverTime {
      * aggregates (Average / Sum / Min / Max) are meaningful over a partial
      * window, so they are left alone.
      */
-    if (
-      evaluateOverTimeOptions.evaluateOverTimeType ===
-      EvaluateOverTimeType.AllValues
-    ) {
+    if (evaluateOverTimeType === EvaluateOverTimeType.AllValues) {
       const isCovered: boolean = this.isWindowCovered({
         windowStart: windowStart,
         windowEnd: now,
@@ -378,10 +375,8 @@ export default class EvaluateOverTime {
     }
 
     if (
-      evaluateOverTimeOptions.evaluateOverTimeType ===
-        EvaluateOverTimeType.AnyValue ||
-      evaluateOverTimeOptions.evaluateOverTimeType ===
-        EvaluateOverTimeType.AllValues
+      evaluateOverTimeType === EvaluateOverTimeType.AnyValue ||
+      evaluateOverTimeType === EvaluateOverTimeType.AllValues
     ) {
       // if its any or all then return the values. Otherwise compute the value based on the type
       return {
@@ -397,7 +392,7 @@ export default class EvaluateOverTime {
       status: OverTimeEvaluationStatus.Evaluated,
       value: this.getValueByEvaluationType({
         values: values as Array<number>,
-        evaluateOverTimeType: evaluateOverTimeOptions.evaluateOverTimeType!,
+        evaluateOverTimeType: evaluateOverTimeType!,
       }),
       sampleCount: values.length,
       noDataReason: null,

package/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.ts

@@ -368,7 +368,10 @@ export default class MetricMonitorCriteria {
         value: numbersInDisplayUnit.length > 0 ? numbersInDisplayUnit : 0,
         threshold: threshold,
         criteriaFilter: input.criteriaFilter,
-        metricDisplayName: metricContext.metricName,
+        metricDisplayName:
+          matchedQuery?.metricAliasData?.title?.trim() ||
+          matchedFormula?.metricAliasData?.title?.trim() ||
+          metricContext.metricName,
         unit: displayUnit,
         /*
          * Only a plain metric criteria has a real metric NAME —

package/Server/Utils/Monitor/MonitorCriteriaExpectationBuilder.ts

@@ -1,5 +1,6 @@
 import {
   CriteriaFilter,
+  CriteriaFilterUtil,
   FilterType,
 } from "../../../Types/Monitor/CriteriaFilter";
 import MetricValueFormatter from "../../../Utils/Monitor/MetricValueFormatter";
@@ -207,8 +208,9 @@ export default class MonitorCriteriaExpectationBuilder {
       );
     }
 
+    // A boolean series saved with an aggregate is judged as All Values.
     const aggregation: string | undefined =
-      criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+      CriteriaFilterUtil.getEffectiveEvaluateOverTimeType(criteriaFilter) ||
       criteriaFilter.metricMonitorOptions?.metricAggregationType;
 
     if (aggregation) {

package/Server/Utils/Monitor/MonitorStepsProjectValidator.ts

@@ -48,30 +48,60 @@ import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/
  * is known to point at a specific model.
  */
 
+/*
+ * Every entry is a getter, not a direct reference.
+ *
+ * The services import each other in a cycle, and this module is part of it:
+ * UserService -> ... -> MonitorService -> ... -> NetworkDeviceService ->
+ * NetworkAlertPolicyEngineService -> MonitorTemplateService -> this module.
+ * Loaded from the API server's entry point, this module runs while UserService
+ * and NetworkDeviceService are still loading. A plain object literal captured
+ * both as `undefined`, and kept them that way for the life of the process. Any
+ * monitorSteps that named an owner user, an incident member or a monitored
+ * network device then failed inside ProjectScopedReferenceValidator with
+ *   TypeError: Cannot read properties of undefined (reading 'getModel')
+ * which the API reports as a bare 500 "Server Error". Monitor creates and
+ * updates, and monitor template saves, all failed this way.
+ *
+ * Which entries a cycle leaves half initialized depends on the whole app's
+ * import graph, so every entry is lazy, not only the two that broke. A getter
+ * defers the lookup to the first property access, by which time every module
+ * has finished initializing. See SerializableObjectDictionary for the same fix.
+ */
 const SERVICE_BY_MODEL: Record<
   MonitorStepsReferenceModel,
   DatabaseService<DatabaseBaseModel>
 > = {
-  [MonitorStepsReferenceModel.MonitorStatus]:
-    MonitorStatusService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.IncidentSeverity]:
-    IncidentSeverityService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.AlertSeverity]:
-    AlertSeverityService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.OnCallDutyPolicy]:
-    OnCallDutyPolicyService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.Label]:
-    LabelService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.Team]:
-    TeamService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.User]:
-    UserService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.IncidentRole]:
-    IncidentRoleService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.TelemetryService]:
-    ServiceService as unknown as DatabaseService<DatabaseBaseModel>,
-  [MonitorStepsReferenceModel.NetworkDevice]:
-    NetworkDeviceService as unknown as DatabaseService<DatabaseBaseModel>,
+  get [MonitorStepsReferenceModel.MonitorStatus](): DatabaseService<DatabaseBaseModel> {
+    return MonitorStatusService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.IncidentSeverity](): DatabaseService<DatabaseBaseModel> {
+    return IncidentSeverityService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.AlertSeverity](): DatabaseService<DatabaseBaseModel> {
+    return AlertSeverityService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.OnCallDutyPolicy](): DatabaseService<DatabaseBaseModel> {
+    return OnCallDutyPolicyService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.Label](): DatabaseService<DatabaseBaseModel> {
+    return LabelService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.Team](): DatabaseService<DatabaseBaseModel> {
+    return TeamService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.User](): DatabaseService<DatabaseBaseModel> {
+    return UserService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.IncidentRole](): DatabaseService<DatabaseBaseModel> {
+    return IncidentRoleService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.TelemetryService](): DatabaseService<DatabaseBaseModel> {
+    return ServiceService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
+  get [MonitorStepsReferenceModel.NetworkDevice](): DatabaseService<DatabaseBaseModel> {
+    return NetworkDeviceService as unknown as DatabaseService<DatabaseBaseModel>;
+  },
 };
 
 export default class MonitorStepsProjectValidator {

package/Server/Utils/Monitor/NetworkDeviceHydrationUtil.ts

@@ -516,6 +516,19 @@ export default class NetworkDeviceHydrationUtil {
    * its site's profile" unrepresentable. The caller chooses what to collect
    * (OIDs / interface walk) — for device polling those come from the
    * device's own snmpOids/walkInterfaces columns.
+   *
+   * `retries` is left out on purpose. A device (like its site and credential
+   * profile) has no retry setting, so there is no user value to carry, and a
+   * number restated here means whatever the probe reading it thinks it
+   * means. It used to be `retries: 3`, written when probes read it as total
+   * attempts; probes now read it as retries after the first attempt, so the
+   * same 3 became four attempts per poll. Absent, every probe version lands
+   * on three attempts from its own default (older probes `?? 3` total, newer
+   * ones two retries), and a failed walk is retried by the next poll cycle
+   * anyway. For Network Device monitors and tests, an absent value falls
+   * through to the step's retry count and then PROBE_MONITOR_RETRY_LIMIT,
+   * like every other monitor type. The timeout is fixed for the same reason:
+   * a device has no setting for it.
    */
   public static buildSnmpMonitorConfig(data: {
     hostname: string;
@@ -533,7 +546,6 @@ export default class NetworkDeviceHydrationUtil {
       snmpV3Auth: NetworkDeviceHydrationUtil.buildSnmpV3Auth(data.credentials),
       oids: data.oids,
       timeout: 5000,
-      retries: 3,
       monitorInterfaces: data.monitorInterfaces,
     };
   }

package/Server/Utils/Monitor/NetworkDeviceMetricUtil.ts

@@ -21,20 +21,15 @@ import SnmpMonitorResponse, {
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
 import CaptureSpan from "../Telemetry/CaptureSpan";
+import { NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME } from "../../../Types/NetworkDevice/NetworkDevicePingMetricNames";
 
 /*
- * Ping round-trip time of a network device, in ms.
- *
- * Ping monitors write their RTT into MonitorMetricType.ResponseTime, but on
- * a network device that series is the SNMP walk's time (and is absent on a
- * ping-only poll), so the RTT needs a series of its own. It sits in the
- * `oneuptime.monitor.ping.*` namespace beside PacketLossPercent and Jitter,
- * which ARE reused from the Ping monitor. MonitorMetricType has no member
- * for it yet; this constant should graduate into that enum (and the device
- * metric catalog) rather than be duplicated.
+ * Ping round-trip time of a network device, in ms. Defined in Common/Types
+ * (NetworkDevicePingMetricNames) because the dashboard reads the series
+ * back and cannot import this server module; re-exported here under the
+ * same name so nothing that already imports it from here has to move.
  */
-export const NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME: string =
-  "oneuptime.monitor.ping.round.trip.time";
+export { NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME };
 
 /*
  * Emits device-scoped metrics from each device poll — reachability, ping