@oneuptime/common 12.0.32 → 12.0.34

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/NetworkTopologyUtil.ts

@@ -42,6 +42,21 @@ export interface TopologyDeviceInput {
   lastPolledAt?: Date | undefined;
   lastSeenAt?: Date | undefined;
   pollingIntervalInMinutes?: number | undefined;
+  /*
+   * How this device's health is established. NULL, empty and anything
+   * unrecognised read as Probe — see NetworkDeviceMonitoringMethodUtil.parse,
+   * which is why an omitted value keeps every existing caller on the poll
+   * rule unchanged.
+   *
+   * Read only when `monitorStatus` below is absent, and load-bearing there:
+   * a monitor-backed device (monitoringMethod "Monitor") with nothing
+   * stamped yet is drawn "unknown", which is what the device list says
+   * about it too. Without this the poll columns above would decide — and on
+   * a device switched over from SNMP they hold the last thing a probe found
+   * before it stopped asking, so a months-old lastSeenAt would draw the node
+   * red while its row in the device list reads Pending.
+   */
+  monitoringMethod?: string | null | undefined;
   interfacesUp?: number | undefined;
   interfacesDown?: number | undefined;
   vendor?: string | undefined;
@@ -1654,9 +1669,13 @@ export default class NetworkTopologyUtil {
 
   /*
    * The shared reachability rule (DeviceReachabilityUtil), mapped onto the
-   * graph's three node states. "Pending" — never polled — is the graph's
-   * "unknown", which is what keeps a device nothing walks from being drawn
-   * as a failure.
+   * graph's three node states. "Pending" — never polled, or monitor-backed
+   * with nothing reported yet — is the graph's "unknown", which is what
+   * keeps a device nothing walks from being drawn as a failure.
+   *
+   * Only reached with no stamped status (deviceStatus took every stamped
+   * one), so the monitoring method is the one fact left that tells the rule
+   * whether the poll columns are evidence or leftovers.
    */
   private static statusFromPoll(
     device: TopologyDeviceInput,
@@ -1668,6 +1687,7 @@ export default class NetworkTopologyUtil {
         lastPolledAt: device.lastPolledAt,
         lastSeenAt: device.lastSeenAt,
         pollingIntervalInMinutes: device.pollingIntervalInMinutes,
+        monitoringMethod: device.monitoringMethod,
       },
       now,
     );

package/Utils/NetworkDevice/DeviceHealthStateUtil.ts

@@ -1,6 +1,7 @@
 import DeviceReachabilityUtil, {
   NetworkDeviceReachability,
 } from "./DeviceReachabilityUtil";
+import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 
 /*
  * The one place that decides how healthy a single NetworkDevice is, and how
@@ -15,10 +16,12 @@ import DeviceReachabilityUtil, {
  *
  * So the rule moves here, and both halves read it:
  *
- *   status  — a monitor-stamped status wins outright; otherwise the shared
- *             reachability rule (the OUTCOME of the last poll, never its
- *             age) decides, and a device nothing has ever polled is
- *             `unknown` rather than a failure.
+ *   status  — for a MONITOR-BACKED device the stamped monitor status is the
+ *             verdict; for a probe-polled device the shared reachability
+ *             rule (the OUTCOME of the last poll, never its age) decides and
+ *             the stamp is informational only (see the input docs); a device
+ *             nothing has ever polled — or a monitor-backed device nothing
+ *             has yet reported on — is `unknown` rather than a failure.
  *   degraded — an up device with dark ports. A switch that answers every
  *             poll while three of its interfaces are down is not down, but
  *             it is exactly what somebody is looking for.
@@ -55,9 +58,18 @@ export type NetworkDeviceHealthState =
  * The columns the classifier reads. Every caller selects exactly these.
  *
  * `monitorStatusIsOffline` is the OFFLINE end of the device's stamped
- * MonitorStatus row — `undefined` when no monitor backs the device (the
- * ordinary case for an SNMP-walked switch), which is what sends the
- * decision down to reachability.
+ * MonitorStatus row — `undefined` when nothing has stamped one, which is
+ * what sends the decision down to reachability.
+ *
+ * It is CONSULTED ONLY FOR A MONITOR-BACKED DEVICE (monitoringMethod
+ * "Monitor"). A probe-polled device can carry a stamp too — a Network
+ * Device monitor watching its walk writes one, and an "interface down →
+ * Offline" criterion will happily stamp Offline on a switch that answers
+ * every ping — but its health source is the poll: `isReachable` is what its
+ * pill, the summary tiles and the Status chip all read, and a classifier
+ * that let the stamp outrank it would colour the site card and the map red
+ * over a device whose own row reads Up. So for a probe-polled device the
+ * stamp stays informational and reachability decides.
  *
  * The offline end and not the operational end, because MonitorStatus is a
  * ladder rather than a pair: the seeded rows run Operational (1) ...
@@ -74,6 +86,24 @@ export interface DeviceHealthStateInput {
   lastPolledAt?: Date | string | null | undefined;
   lastSeenAt?: Date | string | null | undefined;
   pollingIntervalInMinutes?: number | null | undefined;
+  /*
+   * How this device's health is established. NULL, empty and anything
+   * unrecognised read as Probe — see NetworkDeviceMonitoringMethodUtil.parse,
+   * which is why an omitted value keeps every existing caller on the poll
+   * rule unchanged.
+   *
+   * Load-bearing twice. It decides whether `monitorStatusIsOffline` above is
+   * read at all (only for a monitor-backed device). And when a monitor-backed
+   * device has NO stamped status to read — nothing bound yet, or bound and
+   * never evaluated — the shared rule answers Pending ("unknown" here)
+   * rather than falling through to the poll columns, which on such a device
+   * are either NULL or, worse, the last thing a probe found before it
+   * stopped asking: a device switched from Probe to Monitor keeps its old
+   * lastSeenAt until the switch-over clears it, and a caller that dropped
+   * this field would let that months-old timestamp call the device "down" on
+   * the site card while its own row in the device list reads Pending.
+   */
+  monitoringMethod?: string | null | undefined;
   interfacesDown?: number | null | undefined;
 }
 
@@ -96,11 +126,13 @@ export interface DeviceHealthCounts {
 /**
  * The state of one device.
  *
- * Order is load-bearing. A stamped monitor status is the operator's own
- * system of record and beats everything; then hard-down beats everything
- * else, because a device that does not answer has interface counts that
- * are by definition stale; then — and only for a device known to be up —
- * dark ports make it degraded.
+ * Order is load-bearing. On a monitor-backed device the stamped monitor
+ * status is the operator's own system of record and beats everything; on a
+ * probe-polled one the poll's outcome does (the stamp is informational —
+ * see the input docs); then hard-down beats everything else, because a
+ * device that does not answer has interface counts that are by definition
+ * stale; then — and only for a device known to be up — dark ports make it
+ * degraded.
  *
  * Note what this means for a device stamped "Degraded": the ladder does not
  * call it offline, so it is up, and it lands in "degraded" only if it also
@@ -119,9 +151,19 @@ export function deviceHealthState(
 
   let isUp: boolean;
 
+  /*
+   * The stamp is read for a monitor-backed device and nothing else. The
+   * shared reachability rule below applies the same gate, so the two
+   * branches cannot be reached with different ideas of what kind of device
+   * this is.
+   */
+  const isMonitorBacked: boolean =
+    NetworkDeviceMonitoringMethodUtil.isMonitorBacked(device.monitoringMethod);
+
   if (
-    device.monitorStatusIsOffline === true ||
-    device.monitorStatusIsOffline === false
+    isMonitorBacked &&
+    (device.monitorStatusIsOffline === true ||
+      device.monitorStatusIsOffline === false)
   ) {
     // Anything the ladder does not call OFFLINE is up. See the input docs.
     isUp = !device.monitorStatusIsOffline;
@@ -133,6 +175,15 @@ export function deviceHealthState(
           lastPolledAt: device.lastPolledAt,
           lastSeenAt: device.lastSeenAt,
           pollingIntervalInMinutes: device.pollingIntervalInMinutes,
+          /*
+           * Carried so the shared rule knows whether the poll columns above
+           * mean anything. A monitor-backed device only reaches this branch
+           * with NO stamped status (the one above took every stamped one),
+           * so for it this is exactly the "Pending" case — see the input
+           * docs. A probe-polled device always reaches it, stamp or no
+           * stamp, and is judged by its poll.
+           */
+          monitoringMethod: device.monitoringMethod,
         },
         now,
       );

package/Utils/NetworkDevice/DeviceReachabilityUtil.ts

@@ -1,5 +1,6 @@
 import OneUptimeDate from "../../Types/Date";
 import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+import ObjectID from "../../Types/ObjectID";
 
 /*
  * The one place that decides whether a NetworkDevice is reachable.
@@ -21,13 +22,15 @@ import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/Net
  * window.
  *
  * So reachability is now the OUTCOME of the most recent poll —
- * NetworkDevice.isReachable, stamped by the walk pipeline on every ingested
- * walk — and freshness is only a backstop for "the polling pipeline itself
- * stopped", measured generously against the device's own interval.
+ * NetworkDevice.isReachable, stamped by the poll pipeline on every ingested
+ * poll (a ping, plus the SNMP walk on a device that has credentials; the
+ * device is reachable when either answers) — and freshness is only a
+ * backstop for "the polling pipeline itself stopped", measured generously
+ * against the device's own interval.
  *
  * All of which is about a device that gets POLLED. A monitor-backed device
- * (monitoringMethod "Monitor") is never polled at all: no probe, no
- * credentials, no walk. Every poll column on such a row is NULL forever, so
+ * (monitoringMethod "Monitor") is never polled at all: no probe, no ping,
+ * no walk. Every poll column on such a row is NULL forever, so
  * the rule above can only ever answer "Pending" for it — which is
  * OneUptime/oneuptime#3392, a correctly bound ping-only device stuck on
  * Pending. Its health comes from the Monitor bound to it, stamped onto
@@ -69,12 +72,13 @@ export const DEVICE_MIN_STALE_WINDOW_IN_MINUTES: number = 60;
 // The columns this util reads. Every caller selects exactly these.
 export interface DeviceReachabilityInput {
   /*
-   * Outcome of the most recent poll: true = the device answered, false = the
-   * probe could not reach it, null/undefined = never polled, or a row
-   * written before this column existed.
+   * Outcome of the most recent poll: true = the device answered (ping, or
+   * the SNMP walk — either is enough), false = the probe could not reach it
+   * by any means, null/undefined = never polled, or a row written before
+   * this column existed.
    */
   isReachable?: boolean | null | undefined;
-  // When the probe last ATTEMPTED a walk, whatever the outcome.
+  // When the probe last ATTEMPTED a poll, whatever the outcome.
   lastPolledAt?: Date | string | null | undefined;
   // When the device last ANSWERED one.
   lastSeenAt?: Date | string | null | undefined;
@@ -82,7 +86,7 @@ export interface DeviceReachabilityInput {
   pollingIntervalInMinutes?: number | null | undefined;
   /*
    * How this device's health is established. NULL, empty and anything
-   * unrecognised read as SNMP — see NetworkDeviceMonitoringMethodUtil.parse,
+   * unrecognised read as Probe — see NetworkDeviceMonitoringMethodUtil.parse,
    * which is why an omitted value keeps every existing caller on the poll
    * rule unchanged.
    */
@@ -102,6 +106,31 @@ export interface DeviceReachabilityInput {
    * way for the same reason.
    */
   monitorStatusIsOffline?: boolean | null | undefined;
+
+  /*
+   * QUALIFIER inputs. None of the four below moves the Up / Down / Pending
+   * verdict — the rule above is deliberately decided by `isReachable` alone,
+   * so the pill, the summary tiles and the Status chip (all SQL over that one
+   * column) can never disagree. They ride on the same input so a surface can
+   * hand its whole row over once and put the second, explanatory pill
+   * ("SNMP failing", "No probe") beside the verdict; see the predicates in
+   * the dashboard's DeviceStatusUtil.
+   *
+   * `isSnmpReachable`: the outcome of the last SNMP WALK, separate from the
+   * ping — false is a device that answers ping but not SNMP (credentials, or
+   * SNMP disabled on the box), NULL is "no walk was attempted": no usable
+   * credentials, or never polled.
+   */
+  isSnmpReachable?: boolean | null | undefined;
+  // When the last SUCCESSFUL walk completed; only moves on a success.
+  lastSnmpSeenAt?: Date | string | null | undefined;
+  /*
+   * Which probe polls the device, and whether it is allowed to. A probe-polled
+   * device with no probe, or with polling switched off, can never be polled
+   * and is Pending for as long as that stays true.
+   */
+  probeId?: ObjectID | string | null | undefined;
+  isPollingEnabled?: boolean | null | undefined;
 }
 
 export interface DeviceReachabilityResult {
@@ -119,10 +148,10 @@ export interface DeviceReachabilityResult {
   // Latest of lastPolledAt / lastSeenAt; null when neither is set.
   lastContactAt: Date | null;
   /*
-   * True when this verdict came from the bound Monitor rather than from an
-   * SNMP poll. Carried so a surface can word its pill and its tooltip for
-   * what actually decided the answer — "the last SNMP poll reached this
-   * device" is a lie on a device nothing polls.
+   * True when this verdict came from the bound Monitor rather than from a
+   * probe's poll. Carried so a surface can word its pill and its tooltip for
+   * what actually decided the answer — "the last poll reached this device"
+   * is a lie on a device nothing polls.
    */
   isMonitorBacked: boolean;
 }