@oneuptime/common 12.0.14 → 12.0.15

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/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/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,

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

@@ -16,7 +16,7 @@ import SnmpMonitorResponse, {
 } from "../../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
 import SnmpTrap from "../../../../Types/Monitor/SnmpMonitor/SnmpTrap";
 import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
-import EvaluateOverTime from "./EvaluateOverTime";
+import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
 import MetricBaselineService, {
   BaselineSummary,
   MetricBaselineService as MetricBaselineServiceClass,
@@ -173,6 +173,13 @@ export default class SnmpMonitorCriteria {
   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;
@@ -240,37 +247,36 @@ export default class SnmpMonitorCriteria {
       return null;
     }
 
-    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 SNMP device is online
     if (input.criteriaFilter.checkOn === CheckOn.SnmpIsOnline) {
       const currentIsOnline: boolean | Array<boolean> =
-        (overTimeValue as Array<boolean>) ||
+        (overTimeValue as Array<boolean>) ??
         (input.dataToProcess as ProbeMonitorResponse).isOnline;
 
       return CompareCriteria.compareCriteriaBoolean({
@@ -288,9 +294,9 @@ export default class SnmpMonitorCriteria {
       }
 
       const currentResponseTime: number | Array<number> =
-        (overTimeValue as Array<number>) ||
-        snmpResponse?.responseTimeInMs ||
-        (input.dataToProcess as ProbeMonitorResponse).responseTimeInMs;
+        (overTimeValue as Array<number>) ??
+        (snmpResponse?.responseTimeInMs ||
+          (input.dataToProcess as ProbeMonitorResponse).responseTimeInMs);
 
       if (currentResponseTime === null || currentResponseTime === undefined) {
         return null;

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -666,6 +666,7 @@ ${contextBlock}
         await APIRequestCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (apiRequestCriteriaResult) {
@@ -711,6 +712,7 @@ ${contextBlock}
         await IncomingRequestCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (incomingRequestResult) {
@@ -735,6 +737,7 @@ ${contextBlock}
         await SSLMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (sslMonitorResult) {
@@ -747,6 +750,7 @@ ${contextBlock}
         await ServerMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (serverMonitorResult) {
@@ -830,6 +834,7 @@ ${contextBlock}
         await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (snmpMonitorResult) {
@@ -842,6 +847,7 @@ ${contextBlock}
         await DnsMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (dnsMonitorResult) {
@@ -854,6 +860,7 @@ ${contextBlock}
         await DomainMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
           dataToProcess: input.dataToProcess,
           criteriaFilter: input.criteriaFilter,
+          monitoringInterval: input.monitor.monitoringInterval,
         });
 
       if (domainMonitorResult) {
@@ -891,6 +898,7 @@ ${contextBlock}
           {
             dataToProcess: input.dataToProcess,
             criteriaFilter: input.criteriaFilter,
+            monitoringInterval: input.monitor.monitoringInterval,
           },
         );