@oneuptime/common 12.0.14 → 12.0.16

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

@@ -6,15 +6,21 @@ import {
 } from "../../../../Types/Monitor/CriteriaFilter";
 import ExternalStatusPageMonitorResponse from "../../../../Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse";
 import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
-import EvaluateOverTime from "./EvaluateOverTime";
+import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
-import logger from "../../Logger";
 
 export default class ExternalStatusPageMonitorCriteria {
   @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> {
     let threshold: number | string | undefined | null =
       input.criteriaFilter.value;
@@ -26,37 +32,36 @@ export default class ExternalStatusPageMonitorCriteria {
       | ExternalStatusPageMonitorResponse
       | undefined = dataToProcess.externalStatusPageResponse;
 
-    let overTimeValue: Array<number | boolean> | number | boolean | undefined =
-      undefined;
-
-    if (
-      input.criteriaFilter.evaluateOverTime &&
-      input.criteriaFilter.evaluateOverTimeOptions
-    ) {
-      try {
-        overTimeValue = await EvaluateOverTime.getValueOverTime({
-          projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
-          monitorId: input.dataToProcess.monitorId!,
-          evaluateOverTimeOptions: input.criteriaFilter.evaluateOverTimeOptions,
-          metricType: input.criteriaFilter.checkOn,
-        });
+    const overTime: OverTimeCriteriaValue =
+      await EvaluateOverTime.getOverTimeValueForCriteriaFilter({
+        projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
+        monitorId: input.dataToProcess.monitorId!,
+        criteriaFilter: input.criteriaFilter,
+        monitoringInterval: input.monitoringInterval,
+      });
 
-        if (Array.isArray(overTimeValue) && overTimeValue.length === 0) {
-          overTimeValue = undefined;
-        }
-      } catch (err) {
-        logger.error(
-          `Error in getting over time value for ${input.criteriaFilter.checkOn}`,
-        );
-        logger.error(err);
-        overTimeValue = undefined;
-      }
+    /*
+     * The window could not back this over-time filter (nothing recorded yet,
+     * or the monitor has not been running long enough to cover it). Return
+     * the decision the no-data policy already made instead of falling
+     * 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.
+     */
+    if (overTime.earlyReturn) {
+      return overTime.earlyReturn.result;
     }
 
+    const overTimeValue:
+      | Array<number | boolean>
+      | number
+      | boolean
+      | undefined = overTime.value;
+
     // Check if external status page is online
     if (input.criteriaFilter.checkOn === CheckOn.ExternalStatusPageIsOnline) {
       const currentIsOnline: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) ||
+        (overTimeValue as Array<boolean>) ??
         (input.dataToProcess as ProbeMonitorResponse).isOnline;
 
       return CompareCriteria.compareCriteriaBoolean({
@@ -76,9 +81,9 @@ export default class ExternalStatusPageMonitorCriteria {
       }
 
       const currentResponseTime: number | Array<number> =
-        (overTimeValue as Array<number>) ||
-        externalStatusPageResponse?.responseTimeInMs ||
-        (input.dataToProcess as ProbeMonitorResponse).responseTimeInMs;
+        (overTimeValue as Array<number>) ??
+        (externalStatusPageResponse?.responseTimeInMs ||
+          (input.dataToProcess as ProbeMonitorResponse).responseTimeInMs);
 
       if (currentResponseTime === null || currentResponseTime === undefined) {
         return null;

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

@@ -9,7 +9,7 @@ import {
 } from "../../../../Types/Monitor/CriteriaFilter";
 import IncomingMonitorRequest from "../../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import Typeof from "../../../../Types/Typeof";
-import EvaluateOverTime from "./EvaluateOverTime";
+import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
 import CompareCriteria from "./CompareCriteria";
 import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
@@ -19,6 +19,13 @@ export default class IncomingRequestCriteria {
   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> {
     // Server Monitoring Checks
 
@@ -37,36 +44,35 @@ export default class IncomingRequestCriteria {
 
     let value: number | string | undefined = input.criteriaFilter.value;
 
-    let overTimeValue: Array<number | boolean> | number | boolean | undefined =
-      undefined;
-
-    if (
-      input.criteriaFilter.evaluateOverTime &&
-      input.criteriaFilter.evaluateOverTimeOptions
-    ) {
-      try {
-        overTimeValue = await EvaluateOverTime.getValueOverTime({
-          projectId: (input.dataToProcess as IncomingMonitorRequest).projectId,
-          monitorId: input.dataToProcess.monitorId!,
-          evaluateOverTimeOptions: input.criteriaFilter.evaluateOverTimeOptions,
-          metricType: input.criteriaFilter.checkOn,
-        });
-
-        if (Array.isArray(overTimeValue) && overTimeValue.length === 0) {
-          overTimeValue = undefined;
-        }
-      } catch (err) {
-        logger.error(
-          `Error in getting over time value for ${input.criteriaFilter.checkOn}`,
-        );
-        logger.error(err);
-        overTimeValue = undefined;
-      }
+    const overTime: OverTimeCriteriaValue =
+      await EvaluateOverTime.getOverTimeValueForCriteriaFilter({
+        projectId: (input.dataToProcess as IncomingMonitorRequest).projectId,
+        monitorId: input.dataToProcess.monitorId!,
+        criteriaFilter: input.criteriaFilter,
+        monitoringInterval: input.monitoringInterval,
+      });
+
+    /*
+     * The window could not back this over-time filter (nothing recorded yet,
+     * or the monitor has not been running long enough to cover it). Return
+     * the decision the no-data policy already made instead of falling
+     * 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.
+     */
+    if (overTime.earlyReturn) {
+      return overTime.earlyReturn.result;
     }
 
+    const overTimeValue:
+      | Array<number | boolean>
+      | number
+      | boolean
+      | undefined = overTime.value;
+
     if (input.criteriaFilter.checkOn === CheckOn.IsOnline) {
       const currentIsOnline: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) ||
+        (overTimeValue as Array<boolean>) ??
         (input.dataToProcess as ProbeMonitorResponse).isOnline;
 
       return CompareCriteria.compareCriteriaBoolean({
@@ -78,7 +84,7 @@ export default class IncomingRequestCriteria {
     // timeout.
     if (input.criteriaFilter.checkOn === CheckOn.IsRequestTimeout) {
       const currentIsTimeout: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) ||
+        (overTimeValue as Array<boolean>) ??
         (input.dataToProcess as ProbeMonitorResponse).isTimeout;
 
       return CompareCriteria.compareCriteriaBoolean({

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

@@ -1,17 +1,38 @@
 import CaptureSpan from "../../Telemetry/CaptureSpan";
 import DataToProcess from "../DataToProcess";
 import CompareCriteria from "./CompareCriteria";
+import CountAnomaly, {
+  CountAnomalyEvaluation,
+  CountBaselineSummary,
+} from "./CountAnomaly";
 import {
+  AnomalyDetectionMethod,
+  AnomalyDetectionSensitivity,
   CheckOn,
   CriteriaFilter,
+  CriteriaFilterUtil,
 } from "../../../../Types/Monitor/CriteriaFilter";
 import LogMonitorResponse from "../../../../Types/Monitor/LogMonitor/LogMonitorResponse";
+import MonitorStep from "../../../../Types/Monitor/MonitorStep";
+import MonitorStepLogMonitor from "../../../../Types/Monitor/MonitorStepLogMonitor";
+import OneUptimeDate from "../../../../Types/Date";
+import ObjectID from "../../../../Types/ObjectID";
+import LogCountBaselineService from "../../../Services/LogCountBaselineService";
+import { MetricBaselineService as MetricBaselineServiceClass } from "../../../Services/MetricBaselineService";
+import logger from "../../Logger";
 
 export default class LogMonitorCriteria {
   @CaptureSpan()
   public static async isMonitorInstanceCriteriaFilterMet(input: {
     dataToProcess: DataToProcess;
     criteriaFilter: CriteriaFilter;
+    /*
+     * The monitor step carries the log query (services / severities /
+     * evaluation window) the anomaly path scopes its baseline lookup
+     * to. Optional for backward compatibility — static threshold
+     * filters never need it.
+     */
+    monitorStep?: MonitorStep | undefined;
   }): Promise<string | null> {
     // Server Monitoring Checks
 
@@ -19,6 +40,22 @@ export default class LogMonitorCriteria {
       input.criteriaFilter.value;
 
     if (input.criteriaFilter.checkOn === CheckOn.LogCount) {
+      /*
+       * Anomaly filters skip the static threshold entirely: the
+       * observed log rate is compared to this monitor's scope in the
+       * same-hour-of-week LogCountBaseline, mirroring the metric
+       * monitor's baseline path.
+       */
+      if (
+        CriteriaFilterUtil.isAnomalyFilterType(input.criteriaFilter.filterType)
+      ) {
+        return await LogMonitorCriteria.evaluateLogCountAnomaly({
+          logResponse: input.dataToProcess as LogMonitorResponse,
+          criteriaFilter: input.criteriaFilter,
+          monitorStep: input.monitorStep,
+        });
+      }
+
       threshold = CompareCriteria.convertToNumber(threshold);
 
       const currentLogCount: number =
@@ -33,4 +70,99 @@ export default class LogMonitorCriteria {
 
     return null;
   }
+
+  /*
+   * Anomaly path for log counts: normalizes the observed count to a
+   * per-minute rate (the baseline's sample unit) and compares it to the
+   * rolling same-hour-of-week baseline of the monitor's scope (services
+   * and severities; body/attribute filters are not baselined — the
+   * baseline is that scope's full volume, a documented superset).
+   *
+   * Missing or unreliable baselines mean the rule is still learning —
+   * never alert from a thin baseline. Zero-variance baselines are
+   * skipped too: any deviation at all would fire.
+   */
+  private static async evaluateLogCountAnomaly(input: {
+    logResponse: LogMonitorResponse;
+    criteriaFilter: CriteriaFilter;
+    monitorStep?: MonitorStep | undefined;
+  }): Promise<string | null> {
+    const logMonitorStep: MonitorStepLogMonitor | undefined =
+      input.monitorStep?.data?.logMonitor;
+
+    const windowSeconds: number =
+      logMonitorStep?.lastXSecondsOfLogs &&
+      logMonitorStep.lastXSecondsOfLogs > 0
+        ? logMonitorStep.lastXSecondsOfLogs
+        : 60;
+
+    const logCount: number = input.logResponse.logCount || 0;
+    const observedPerMinute: number = (logCount * 60) / windowSeconds;
+
+    const sensitivity: AnomalyDetectionSensitivity =
+      (input.criteriaFilter.metricMonitorOptions?.anomalyDetection
+        ?.sensitivity as AnomalyDetectionSensitivity | undefined) ||
+      AnomalyDetectionSensitivity.Medium;
+    const sigmaCount: number =
+      MetricBaselineServiceClass.sigmaForSensitivity(sensitivity);
+    const method: AnomalyDetectionMethod =
+      (input.criteriaFilter.metricMonitorOptions?.anomalyDetection?.method as
+        | AnomalyDetectionMethod
+        | undefined) || AnomalyDetectionMethod.MeanStddev;
+
+    let baseline: CountBaselineSummary | null = null;
+    try {
+      baseline = await LogCountBaselineService.getBaseline({
+        projectId: input.logResponse.projectId.toString(),
+        telemetryServiceIds: logMonitorStep?.telemetryServiceIds?.map(
+          (id: ObjectID) => {
+            return id.toString();
+          },
+        ),
+        severityTexts: logMonitorStep?.severityTexts,
+        hourOfWeek: MetricBaselineServiceClass.computeHourOfWeek(
+          OneUptimeDate.getCurrentDate(),
+        ),
+        windowDays:
+          input.criteriaFilter.metricMonitorOptions?.anomalyDetection
+            ?.windowDays,
+        minSamples:
+          input.criteriaFilter.metricMonitorOptions?.anomalyDetection
+            ?.minSamples,
+      });
+    } catch (err) {
+      logger.error("Error fetching log count baseline for anomaly criteria");
+      logger.error(err);
+      return null;
+    }
+
+    if (!baseline || !baseline.isReliable) {
+      // Cold start: the baseline is still learning; nothing to compare to.
+      return null;
+    }
+
+    const evaluation: CountAnomalyEvaluation | null = CountAnomaly.evaluate({
+      observedPerMinute,
+      stats: baseline,
+      sigmaCount,
+      method,
+      filterType: input.criteriaFilter.filterType,
+    });
+
+    if (!evaluation || !evaluation.breaches) {
+      return null;
+    }
+
+    const direction: string = evaluation.observedSigma >= 0 ? "above" : "below";
+
+    return (
+      `Log count ${logCount} over the last ${windowSeconds} seconds ` +
+      `(${observedPerMinute.toFixed(2)} logs/min) is ` +
+      `${Math.abs(evaluation.observedSigma).toFixed(2)}σ ${direction} the same-hour baseline ` +
+      `(${method === AnomalyDetectionMethod.MedianMad ? "median" : "mean"} ` +
+      `${evaluation.center.toFixed(2)} logs/min, σ ${evaluation.spread.toFixed(2)}, ` +
+      `${baseline.sampleCount} samples over ${baseline.windowDays} days, ` +
+      `sensitivity ${sensitivity}).`
+    );
+  }
 }

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

@@ -8,15 +8,21 @@ import {
 } from "../../../../Types/Monitor/CriteriaFilter";
 import SslMonitorResponse from "../../../../Types/Monitor/SSLMonitor/SslMonitorResponse";
 import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
-import EvaluateOverTime from "./EvaluateOverTime";
+import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
-import logger from "../../Logger";
 
 export default class ServerMonitorCriteria {
   @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> {
     let threshold: number | string | undefined | null =
       input.criteriaFilter.value;
@@ -27,36 +33,35 @@ export default class ServerMonitorCriteria {
     const sslResponse: SslMonitorResponse | undefined =
       dataToProcess.sslResponse;
 
-    let overTimeValue: Array<number | boolean> | number | boolean | undefined =
-      undefined;
+    const overTime: OverTimeCriteriaValue =
+      await EvaluateOverTime.getOverTimeValueForCriteriaFilter({
+        projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
+        monitorId: input.dataToProcess.monitorId!,
+        criteriaFilter: input.criteriaFilter,
+        monitoringInterval: input.monitoringInterval,
+      });
 
-    if (
-      input.criteriaFilter.evaluateOverTime &&
-      input.criteriaFilter.evaluateOverTimeOptions
-    ) {
-      try {
-        overTimeValue = await EvaluateOverTime.getValueOverTime({
-          projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
-          monitorId: input.dataToProcess.monitorId!,
-          evaluateOverTimeOptions: input.criteriaFilter.evaluateOverTimeOptions,
-          metricType: input.criteriaFilter.checkOn,
-        });
-
-        if (Array.isArray(overTimeValue) && overTimeValue.length === 0) {
-          overTimeValue = undefined;
-        }
-      } catch (err) {
-        logger.error(
-          `Error in getting over time value for ${input.criteriaFilter.checkOn}`,
-        );
-        logger.error(err);
-        overTimeValue = undefined;
-      }
+    /*
+     * The window could not back this over-time filter (nothing recorded yet,
+     * or the monitor has not been running long enough to cover it). Return
+     * the decision the no-data policy already made instead of falling
+     * 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.
+     */
+    if (overTime.earlyReturn) {
+      return overTime.earlyReturn.result;
     }
 
+    const overTimeValue:
+      | Array<number | boolean>
+      | number
+      | boolean
+      | undefined = overTime.value;
+
     if (input.criteriaFilter.checkOn === CheckOn.IsOnline) {
       const currentIsOnline: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) ||
+        (overTimeValue as Array<boolean>) ??
         (input.dataToProcess as ProbeMonitorResponse).isOnline;
 
       return CompareCriteria.compareCriteriaBoolean({
@@ -68,7 +73,7 @@ export default class ServerMonitorCriteria {
     // timeout.
     if (input.criteriaFilter.checkOn === CheckOn.IsRequestTimeout) {
       const currentIsTimeout: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) ||
+        (overTimeValue as Array<boolean>) ??
         (input.dataToProcess as ProbeMonitorResponse).isTimeout;
 
       return CompareCriteria.compareCriteriaBoolean({

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

@@ -0,0 +1,35 @@
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import SecurityEventsMonitorResponse from "../../../../Types/Monitor/SecurityEventsMonitor/SecurityEventsMonitorResponse";
+
+export default class SecurityEventsMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    if (input.criteriaFilter.checkOn === CheckOn.SecurityEventCount) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      const currentCount: number =
+        (input.dataToProcess as SecurityEventsMonitorResponse)
+          .securityEventCount || 0;
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: currentCount,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    return null;
+  }
+}

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

@@ -1,6 +1,6 @@
 import DataToProcess from "../DataToProcess";
 import CompareCriteria from "./CompareCriteria";
-import EvaluateOverTime from "./EvaluateOverTime";
+import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
 import OneUptimeDate from "../../../../Types/Date";
 import { BasicDiskMetrics } from "../../../../Types/Infrastructure/BasicMetrics";
 import { JSONObject } from "../../../../Types/JSON";
@@ -20,39 +20,60 @@ export default class ServerMonitorCriteria {
   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> {
     // Server Monitoring Checks
 
     let threshold: number | string | undefined | null =
       input.criteriaFilter.value;
-    let overTimeValue: Array<number | boolean> | number | boolean | undefined =
-      undefined;
+    const overTime: OverTimeCriteriaValue =
+      await EvaluateOverTime.getOverTimeValueForCriteriaFilter({
+        projectId: (input.dataToProcess as ServerMonitorResponse).projectId,
+        monitorId: input.dataToProcess.monitorId!,
+        criteriaFilter: input.criteriaFilter,
+        /*
+         * Only the disk-usage series carries a diskPath attribute, so
+         * scoping any other series by it would filter against an attribute
+         * no row has - and an empty window now means "cannot judge yet"
+         * rather than "compare the live value", which would silence the
+         * filter outright.
+         */
+        miscData:
+          input.criteriaFilter.checkOn === CheckOn.DiskUsagePercent
+            ? (input.criteriaFilter.serverMonitorOptions as JSONObject)
+            : undefined,
+        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.
+     *
+     * "Is Online" is exempt: for a server monitor the absence of data IS the
+     * signal, and the differenceInMinutes check below already implements the
+     * "wait this long before calling it offline" behaviour off the agent's
+     * last check-in time. Letting it fall through preserves that.
+     */
     if (
-      input.criteriaFilter.evaluateOverTime &&
-      input.criteriaFilter.evaluateOverTimeOptions
+      overTime.earlyReturn &&
+      input.criteriaFilter.checkOn !== CheckOn.IsOnline
     ) {
-      try {
-        overTimeValue = await EvaluateOverTime.getValueOverTime({
-          projectId: (input.dataToProcess as ServerMonitorResponse).projectId,
-          monitorId: input.dataToProcess.monitorId!,
-          evaluateOverTimeOptions: input.criteriaFilter.evaluateOverTimeOptions,
-          metricType: input.criteriaFilter.checkOn,
-          miscData: input.criteriaFilter.serverMonitorOptions as JSONObject,
-        });
-
-        if (Array.isArray(overTimeValue) && overTimeValue.length === 0) {
-          overTimeValue = undefined;
-        }
-      } catch (err) {
-        logger.error(
-          `Error in getting over time value for ${input.criteriaFilter.checkOn}`,
-        );
-        logger.error(err);
-        overTimeValue = undefined;
-      }
+      return overTime.earlyReturn.result;
     }
 
+    const overTimeValue:
+      | Array<number | boolean>
+      | number
+      | boolean
+      | undefined = overTime.value;
+
     const lastCheckTime: Date = (input.dataToProcess as ServerMonitorResponse)
       .requestReceivedAt;
 
@@ -108,7 +129,7 @@ export default class ServerMonitorCriteria {
       differenceInMinutes >= offlineIfNotCheckedInMinutes
     ) {
       const currentIsOnline: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) || false; // false because no request receieved in the last 2 minutes
+        (overTimeValue as Array<boolean>) ?? false; // false because no request receieved in the last 2 minutes
 
       logger.debug(`Current Is Online: ${currentIsOnline}`);
 
@@ -127,7 +148,7 @@ export default class ServerMonitorCriteria {
       differenceInMinutes < offlineIfNotCheckedInMinutes
     ) {
       const currentIsOnline: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) || true; // true because request receieved in the last 2 minutes
+        (overTimeValue as Array<boolean>) ?? true; // true because request receieved in the last 2 minutes
 
       logger.debug(`Current Is Online: ${currentIsOnline}`);
 
@@ -148,10 +169,10 @@ export default class ServerMonitorCriteria {
       threshold = CompareCriteria.convertToNumber(threshold);
 
       const currentCpuPercent: number | Array<number> =
-        (overTimeValue as Array<number>) ||
-        (input.dataToProcess as ServerMonitorResponse)
+        (overTimeValue as Array<number>) ??
+        ((input.dataToProcess as ServerMonitorResponse)
           .basicInfrastructureMetrics?.cpuMetrics.percentUsed ||
-        0;
+          0);
 
       return CompareCriteria.compareCriteriaNumbers({
         value: currentCpuPercent,
@@ -167,10 +188,10 @@ export default class ServerMonitorCriteria {
       threshold = CompareCriteria.convertToNumber(threshold);
 
       const memoryPercent: number | Array<number> =
-        (overTimeValue as Array<number>) ||
-        (input.dataToProcess as ServerMonitorResponse)
+        (overTimeValue as Array<number>) ??
+        ((input.dataToProcess as ServerMonitorResponse)
           .basicInfrastructureMetrics?.memoryMetrics.percentUsed ||
-        0;
+          0);
 
       return CompareCriteria.compareCriteriaNumbers({
         value: memoryPercent,
@@ -201,8 +222,16 @@ export default class ServerMonitorCriteria {
       const diskUsagePercent: number =
         diskMetric?.percentUsed ?? diskMetric?.percentFree ?? 0;
 
+      /*
+       * Disk usage was the one server metric that computed its over-time
+       * window and then threw it away, comparing the reading from this check
+       * instead - so "evaluate over time" was a no-op here.
+       */
+      const value: number | Array<number> =
+        (overTimeValue as Array<number>) ?? diskUsagePercent;
+
       return CompareCriteria.compareCriteriaNumbers({
-        value: diskUsagePercent,
+        value: value,
         threshold: threshold as number,
         criteriaFilter: input.criteriaFilter,
       });
@@ -232,7 +261,7 @@ export default class ServerMonitorCriteria {
       }
 
       const value: number | Array<number> =
-        (overTimeValue as Array<number>) || currentLoad || 0;
+        (overTimeValue as Array<number>) ?? (currentLoad || 0);
 
       return CompareCriteria.compareCriteriaNumbers({
         value: value,
@@ -248,10 +277,10 @@ export default class ServerMonitorCriteria {
       threshold = CompareCriteria.convertToNumber(threshold);
 
       const swapPercent: number | Array<number> =
-        (overTimeValue as Array<number>) ||
-        (input.dataToProcess as ServerMonitorResponse)
+        (overTimeValue as Array<number>) ??
+        ((input.dataToProcess as ServerMonitorResponse)
           .basicInfrastructureMetrics?.memoryMetrics?.swapPercentUsed ||
-        0;
+          0);
 
       return CompareCriteria.compareCriteriaNumbers({
         value: swapPercent,
@@ -267,10 +296,10 @@ export default class ServerMonitorCriteria {
       threshold = CompareCriteria.convertToNumber(threshold);
 
       const ioWaitPercent: number | Array<number> =
-        (overTimeValue as Array<number>) ||
-        (input.dataToProcess as ServerMonitorResponse)
+        (overTimeValue as Array<number>) ??
+        ((input.dataToProcess as ServerMonitorResponse)
           .basicInfrastructureMetrics?.cpuMetrics?.timeIoWaitPercent ||
-        0;
+          0);
 
       return CompareCriteria.compareCriteriaNumbers({
         value: ioWaitPercent,