@oneuptime/common 12.0.32 → 12.0.33

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

@@ -0,0 +1,190 @@
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import {
+  DatabaseMetricDefinition,
+  getDatabaseMetricByMetricType,
+} from "../../../../Types/Monitor/DatabaseMetricCatalog";
+import DatabaseMonitorResponse, {
+  DatabaseMetricGroupStatus,
+} from "../../../../Types/Monitor/DatabaseMonitor/DatabaseMonitorResponse";
+import MonitorMetricType from "../../../../Types/Monitor/MonitorMetricType";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+export default class DatabaseMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+    /*
+     * The monitor's monitoringInterval cron. Over-time filters use it to
+     * work out how many samples a fully covered window should hold, so a
+     * monitor that has only just started is not mistaken for one whose
+     * whole window is breaching.
+     */
+    monitoringInterval?: string | undefined;
+  }): Promise<string | null> {
+    const dataToProcess: ProbeMonitorResponse =
+      input.dataToProcess as ProbeMonitorResponse;
+
+    const databaseResponse: DatabaseMonitorResponse | undefined =
+      dataToProcess.databaseMonitorResponse;
+
+    /*
+     * Resolved once for every CheckOn. Database Metric filters name their
+     * series in databaseMonitorOptions.metricType rather than in the CheckOn,
+     * which is why EvaluateOverTime resolves the series from the whole filter.
+     */
+    const overTime: OverTimeCriteriaValue =
+      await EvaluateOverTime.getOverTimeValueForCriteriaFilter({
+        projectId: dataToProcess.projectId,
+        monitorId: input.dataToProcess.monitorId!,
+        criteriaFilter: input.criteriaFilter,
+        monitoringInterval: input.monitoringInterval,
+      });
+
+    /*
+     * The window could not back this over-time filter, so the no-data policy
+     * has already decided it - do not fall through to the value that arrived
+     * with this one check. That fallback is what let "all values over the
+     * last N minutes" fire off a single bad reading.
+     *
+     * "Database Is Online" is exempt, mirroring the server monitor. An
+     * unreachable database is the one signal that must always reach its
+     * criteria: a monitor whose window is still filling, or whose metric
+     * write has not caught up, would otherwise be unable to go offline at
+     * all while the dashboard shows the connection failing.
+     */
+    if (
+      overTime.earlyReturn &&
+      input.criteriaFilter.checkOn !== CheckOn.DatabaseIsOnline
+    ) {
+      return overTime.earlyReturn.result;
+    }
+
+    const overTimeValue:
+      | Array<number | boolean>
+      | number
+      | boolean
+      | undefined = overTime.value;
+
+    // Could the probe connect and run the baseline probe query?
+    if (input.criteriaFilter.checkOn === CheckOn.DatabaseIsOnline) {
+      const currentIsOnline: boolean | Array<boolean> =
+        (overTimeValue as Array<boolean>) ?? dataToProcess.isOnline;
+
+      return CompareCriteria.compareCriteriaBoolean({
+        value: currentIsOnline,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    /*
+     * One branch for all of the catalog's series: the filter names the one it
+     * reads in databaseMonitorOptions.metricType, exactly as disk usage names
+     * a mount and an SNMP value names an OID.
+     *
+     * Thresholds are whole numbers - CompareCriteria.convertToNumber parses
+     * with parseInt, so "99.5" is compared as 99. Every catalog unit is
+     * chosen so an integral threshold is the natural one to type.
+     */
+    if (input.criteriaFilter.checkOn === CheckOn.DatabaseMetric) {
+      const metricType: MonitorMetricType | undefined =
+        input.criteriaFilter.databaseMonitorOptions?.metricType;
+
+      if (!metricType) {
+        return null;
+      }
+
+      const definition: DatabaseMetricDefinition | null =
+        getDatabaseMetricByMetricType(metricType);
+
+      if (!definition) {
+        return null;
+      }
+
+      const value: number | undefined = databaseResponse?.metrics[metricType];
+
+      /*
+       * The metric was not collected on this check - the engine cannot report
+       * it, the monitoring login is missing the grant its group needs, or the
+       * group timed out. Absent is not zero, and a criteria that cannot see a
+       * value must never claim one breached: a revoked grant would otherwise
+       * raise an incident about a database that is perfectly healthy.
+       * CheckOn.DatabaseCollectionError is how an operator alerts on lost
+       * visibility.
+       */
+      if (value === undefined || value === null) {
+        return null;
+      }
+
+      const threshold: number | null = CompareCriteria.convertToNumber(
+        input.criteriaFilter.value,
+      );
+
+      if (threshold === null) {
+        return null;
+      }
+
+      const result: string | null = CompareCriteria.compareCriteriaNumbers({
+        value: (overTimeValue as Array<number>) ?? value,
+        threshold: threshold,
+        criteriaFilter: input.criteriaFilter,
+        unit: definition.unit || undefined,
+      });
+
+      if (result) {
+        return `${definition.friendlyName} - ${result}`;
+      }
+
+      return null;
+    }
+
+    // Groups that could not be collected, as one operator-facing line each.
+    if (input.criteriaFilter.checkOn === CheckOn.DatabaseCollectionError) {
+      const collectionIssues: string = (
+        databaseResponse?.unavailableGroups || []
+      )
+        .map((status: DatabaseMetricGroupStatus) => {
+          return `${status.group}: ${status.message}`;
+        })
+        .join("; ");
+
+      /*
+       * compareEmptyAndNotEmpty tests for null/undefined, and an empty string
+       * would read as "not empty" - so a check with nothing to report has to
+       * arrive as undefined for "Is Empty" to mean "collection was clean".
+       */
+      const emptyNotEmptyResult: string | null =
+        CompareCriteria.compareEmptyAndNotEmpty({
+          value: collectionIssues || undefined,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (emptyNotEmptyResult) {
+        return emptyNotEmptyResult;
+      }
+
+      if (
+        input.criteriaFilter.value !== null &&
+        input.criteriaFilter.value !== undefined &&
+        collectionIssues
+      ) {
+        return CompareCriteria.compareCriteriaStrings({
+          value: collectionIssues,
+          threshold: input.criteriaFilter.value.toString(),
+          criteriaFilter: input.criteriaFilter,
+        });
+      }
+
+      return null;
+    }
+
+    return null;
+  }
+}

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

@@ -177,6 +177,7 @@ export default class EvaluateOverTime {
         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 {
@@ -220,9 +221,15 @@ export default class EvaluateOverTime {
       };
     }
 
+    /*
+     * Resolved from the whole filter, not from the CheckOn alone: a Database
+     * Metric filter names its series in databaseMonitorOptions.metricType, so
+     * the CheckOn-only lookup would return null for every one of them and
+     * silently downgrade the filter to an instantaneous comparison.
+     */
     const metricName: MonitorMetricType | null =
-      MonitorMetricTypeUtil.getMonitorMetricTypeByCheckOnOrNull(
-        data.criteriaFilter.checkOn,
+      MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+        data.criteriaFilter,
       );
 
     if (!metricName) {

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

@@ -27,6 +27,22 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
 import logger from "../../Logger";
 
 export default class SnmpMonitorCriteria {
+  /*
+   * Every CheckOn whose value comes out of the SNMP walk. Reachability
+   * (SnmpIsOnline) and traps are the two that do not.
+   */
+  private static isWalkDependentCheckOn(checkOn: CheckOn): boolean {
+    return (
+      checkOn === CheckOn.SnmpWalkIsSucceeding ||
+      checkOn === CheckOn.SnmpResponseTime ||
+      checkOn === CheckOn.SnmpOidExists ||
+      checkOn === CheckOn.SnmpOidValue ||
+      checkOn === CheckOn.SnmpInterfaceIsDown ||
+      checkOn === CheckOn.SnmpInterfaceUtilizationPercent ||
+      checkOn === CheckOn.SnmpInterfaceErrorsPerSecond
+    );
+  }
+
   /*
    * Interface scope for the interface CheckOns: when the criteria carries
    * snmpMonitorOptions.interfaceName, only interfaces whose name or alias
@@ -256,6 +272,29 @@ export default class SnmpMonitorCriteria {
       return null;
     }
 
+    /*
+     * No walk, no verdict. A device without usable SNMP credentials is only
+     * pinged, and the walk pipeline hands its monitors a response with
+     * `snmpResponse` undefined - never a synthesized failure. Every criterion
+     * that reads the walk is therefore NOT EVALUATED on such a poll (null),
+     * rather than breaching: "OID Exists is False" must not raise an
+     * incident on a device nobody ever asked an OID of, and "Walk Is
+     * Succeeding is False" must mean "attempted and failed". Reachability
+     * (SnmpIsOnline) is read from the top-level isOnline further down and
+     * is unaffected.
+     *
+     * This runs before the over-time lookup on purpose: a window of stored
+     * walk-time samples says nothing about a poll that walked nothing.
+     */
+    if (
+      SnmpMonitorCriteria.isWalkDependentCheckOn(
+        input.criteriaFilter.checkOn,
+      ) &&
+      !snmpResponse
+    ) {
+      return null;
+    }
+
     const overTime: OverTimeCriteriaValue =
       await EvaluateOverTime.getOverTimeValueForCriteriaFilter({
         projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
@@ -282,7 +321,12 @@ export default class SnmpMonitorCriteria {
       | boolean
       | undefined = overTime.value;
 
-    // Check if SNMP device is online
+    /*
+     * Device reachability: the top-level isOnline is "answered ping OR the
+     * walk succeeded", stamped by the walk pipeline - the same verdict the
+     * device list's status pill shows. Deliberately not the walk's own
+     * isOnline, which the next CheckOn covers.
+     */
     if (input.criteriaFilter.checkOn === CheckOn.SnmpIsOnline) {
       const currentIsOnline: boolean | Array<boolean> =
         (overTimeValue as Array<boolean>) ??
@@ -294,6 +338,22 @@ export default class SnmpMonitorCriteria {
       });
     }
 
+    /*
+     * The walk itself. Gated above: a poll with no walk returns null before
+     * reaching here, so `snmpResponse` is present and "False" genuinely
+     * means the walk was attempted and failed.
+     */
+    if (input.criteriaFilter.checkOn === CheckOn.SnmpWalkIsSucceeding) {
+      if (!snmpResponse) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaBoolean({
+        value: snmpResponse.isOnline === true,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
     // Check SNMP response time
     if (input.criteriaFilter.checkOn === CheckOn.SnmpResponseTime) {
       threshold = CompareCriteria.convertToNumber(threshold);

package/Server/Utils/Monitor/MonitorCriteriaDataExtractor.ts

@@ -9,6 +9,7 @@ import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMo
 import CustomCodeMonitorResponse from "../../../Types/Monitor/CustomCodeMonitor/CustomCodeMonitorResponse";
 import SyntheticMonitorResponse from "../../../Types/Monitor/SyntheticMonitors/SyntheticMonitorResponse";
 import SslMonitorResponse from "../../../Types/Monitor/SSLMonitor/SslMonitorResponse";
+import DatabaseMonitorResponse from "../../../Types/Monitor/DatabaseMonitor/DatabaseMonitorResponse";
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import { CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
 import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
@@ -142,6 +143,19 @@ export default class MonitorCriteriaDataExtractor {
     return null;
   }
 
+  public static getDatabaseMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): DatabaseMonitorResponse | null {
+    const probeResponse: ProbeMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getProbeMonitorResponse(dataToProcess);
+
+    if (probeResponse?.databaseMonitorResponse) {
+      return probeResponse.databaseMonitorResponse;
+    }
+
+    return null;
+  }
+
   public static extractMetricValues(input: {
     criteriaFilter: CriteriaFilter;
     dataToProcess: DataToProcess;

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -25,6 +25,7 @@ import DnsMonitorCriteria from "./Criteria/DnsMonitorCriteria";
 import DomainMonitorCriteria from "./Criteria/DomainMonitorCriteria";
 import DnssecMonitorCriteria from "./Criteria/DnssecMonitorCriteria";
 import SqlMonitorCriteria from "./Criteria/SqlMonitorCriteria";
+import DatabaseMonitorCriteria from "./Criteria/DatabaseMonitorCriteria";
 import ExternalStatusPageMonitorCriteria from "./Criteria/ExternalStatusPageMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
@@ -48,6 +49,9 @@ import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import RequestFailedDetails from "../../../Types/Probe/RequestFailedDetails";
 import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import SqlMonitorResponse from "../../../Types/Monitor/SqlMonitor/SqlMonitorResponse";
+import DatabaseMonitorResponse, {
+  DatabaseMetricGroupStatus,
+} from "../../../Types/Monitor/DatabaseMonitor/DatabaseMonitorResponse";
 import MonitorType from "../../../Types/Monitor/MonitorType";
 import { CheckOn, CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
 import OneUptimeDate from "../../../Types/Date";
@@ -883,6 +887,38 @@ ${contextBlock}
         };
       }
 
+      if (input.monitor.monitorType === MonitorType.Database) {
+        const databaseResponse: DatabaseMonitorResponse | undefined = (
+          input.dataToProcess as ProbeMonitorResponse
+        ).databaseMonitorResponse;
+
+        /*
+         * metrics is exposed raw, keyed by series name, so an expression can
+         * read any of the catalog's series without a variable per metric:
+         * {{metrics['oneuptime.monitor.database.connections.used.percent']}} > 90
+         *
+         * Connection details are deliberately absent - host, username and
+         * password never travel into an expression sandbox.
+         */
+        storageMap = {
+          isOnline: (input.dataToProcess as ProbeMonitorResponse).isOnline,
+          engineVersion: databaseResponse?.engineVersion,
+          connectionError: databaseResponse?.connectionError,
+          collectedGroups: databaseResponse?.collectedGroups,
+          unavailableGroups: (databaseResponse?.unavailableGroups || []).map(
+            (status: DatabaseMetricGroupStatus): JSONObject => {
+              return {
+                group: status.group,
+                reason: status.reason,
+                message: status.message,
+                remediation: status.remediation,
+              };
+            },
+          ),
+          metrics: databaseResponse?.metrics,
+        };
+      }
+
       let expression: string = input.criteriaFilter.value as string;
       expression = VMUtil.replaceValueInPlace(storageMap, expression, false);
 
@@ -1173,6 +1209,19 @@ ${contextBlock}
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.Database) {
+      const databaseMonitorResult: string | null =
+        await DatabaseMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
+        });
+
+      if (databaseMonitorResult) {
+        return databaseMonitorResult;
+      }
+    }
+
     if (input.monitor.monitorType === MonitorType.ExternalStatusPage) {
       const externalStatusPageResult: string | null =
         await ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet(