@oneuptime/common 8.0.5516 → 8.0.5544

package/Server/Utils/Monitor/MonitorCriteriaDataExtractor.ts

@@ -0,0 +1,208 @@
+import DataToProcess from "./DataToProcess";
+import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
+import ServerMonitorResponse from "../../../Types/Monitor/ServerMonitor/ServerMonitorResponse";
+import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
+import LogMonitorResponse from "../../../Types/Monitor/LogMonitor/LogMonitorResponse";
+import TraceMonitorResponse from "../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
+import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import CustomCodeMonitorResponse from "../../../Types/Monitor/CustomCodeMonitor/CustomCodeMonitorResponse";
+import SyntheticMonitorResponse from "../../../Types/Monitor/SyntheticMonitors/SyntheticMonitorResponse";
+import SslMonitorResponse from "../../../Types/Monitor/SSLMonitor/SslMonitorResponse";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import { CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
+import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
+import AggregateModel from "../../../Types/BaseDatabase/AggregatedModel";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+
+export default class MonitorCriteriaDataExtractor {
+  public static getProbeMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): ProbeMonitorResponse | null {
+    if ((dataToProcess as ProbeMonitorResponse).monitorStepId) {
+      return dataToProcess as ProbeMonitorResponse;
+    }
+
+    return null;
+  }
+
+  public static getServerMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): ServerMonitorResponse | null {
+    if ((dataToProcess as ServerMonitorResponse).hostname) {
+      return dataToProcess as ServerMonitorResponse;
+    }
+
+    return null;
+  }
+
+  public static getIncomingMonitorRequest(
+    dataToProcess: DataToProcess,
+  ): IncomingMonitorRequest | null {
+    if (
+      (dataToProcess as IncomingMonitorRequest).incomingRequestReceivedAt !==
+      undefined
+    ) {
+      return dataToProcess as IncomingMonitorRequest;
+    }
+
+    return null;
+  }
+
+  public static getLogMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): LogMonitorResponse | null {
+    if ((dataToProcess as LogMonitorResponse).logCount !== undefined) {
+      return dataToProcess as LogMonitorResponse;
+    }
+
+    return null;
+  }
+
+  public static getTraceMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): TraceMonitorResponse | null {
+    if ((dataToProcess as TraceMonitorResponse).spanCount !== undefined) {
+      return dataToProcess as TraceMonitorResponse;
+    }
+
+    return null;
+  }
+
+  public static getMetricMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): MetricMonitorResponse | null {
+    if ((dataToProcess as MetricMonitorResponse).metricResult !== undefined) {
+      return dataToProcess as MetricMonitorResponse;
+    }
+
+    return null;
+  }
+
+  public static getCustomCodeMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): CustomCodeMonitorResponse | null {
+    const probeResponse: ProbeMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getProbeMonitorResponse(dataToProcess);
+
+    if (probeResponse?.customCodeMonitorResponse) {
+      return probeResponse.customCodeMonitorResponse;
+    }
+
+    return null;
+  }
+
+  public static getSyntheticMonitorResponses(
+    dataToProcess: DataToProcess,
+  ): Array<SyntheticMonitorResponse> {
+    const probeResponse: ProbeMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getProbeMonitorResponse(dataToProcess);
+
+    return probeResponse?.syntheticMonitorResponse || [];
+  }
+
+  public static getSslResponse(
+    dataToProcess: DataToProcess,
+  ): SslMonitorResponse | null {
+    const probeResponse: ProbeMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getProbeMonitorResponse(dataToProcess);
+
+    if (probeResponse?.sslResponse) {
+      return probeResponse.sslResponse;
+    }
+
+    return null;
+  }
+
+  public static extractMetricValues(input: {
+    criteriaFilter: CriteriaFilter;
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+  }): { alias: string | null; values: Array<number> } | null {
+    const metricResponse: MetricMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getMetricMonitorResponse(
+        input.dataToProcess,
+      );
+
+    if (!metricResponse) {
+      return null;
+    }
+
+    const aggregatedResults: Array<AggregatedResult> =
+      metricResponse.metricResult || [];
+
+    if (!aggregatedResults.length) {
+      return {
+        alias: input.criteriaFilter.metricMonitorOptions?.metricAlias || null,
+        values: [],
+      };
+    }
+
+    let alias: string | null =
+      input.criteriaFilter.metricMonitorOptions?.metricAlias || null;
+
+    let result: AggregatedResult | undefined;
+
+    if (alias) {
+      const queryConfigs: Array<MetricQueryConfigData> =
+        input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
+        [];
+
+      let aliasIndex: number = queryConfigs.findIndex(
+        (queryConfig: MetricQueryConfigData) => {
+          return queryConfig.metricAliasData?.metricVariable === alias;
+        },
+      );
+
+      if (aliasIndex < 0) {
+        const formulaConfigs: Array<MetricFormulaConfigData> =
+          input.monitorStep.data?.metricMonitor?.metricViewConfig
+            ?.formulaConfigs || [];
+
+        const formulaIndex: number = formulaConfigs.findIndex(
+          (formulaConfig: MetricFormulaConfigData) => {
+            return formulaConfig.metricAliasData?.metricVariable === alias;
+          },
+        );
+
+        if (formulaIndex >= 0) {
+          aliasIndex = queryConfigs.length + formulaIndex;
+        }
+      }
+
+      if (aliasIndex >= 0 && aliasIndex < aggregatedResults.length) {
+        result = aggregatedResults[aliasIndex];
+      }
+    }
+
+    if (!result) {
+      result = aggregatedResults[0];
+      if (!alias) {
+        const defaultAlias: string | undefined =
+          input.monitorStep.data?.metricMonitor?.metricViewConfig
+            ?.queryConfigs?.[0]?.metricAliasData?.metricVariable;
+        alias = defaultAlias || null;
+      }
+    }
+
+    if (!result) {
+      return {
+        alias: alias,
+        values: [],
+      };
+    }
+
+    const values: Array<number> = result.data
+      .map((entry: AggregateModel) => {
+        return entry.value;
+      })
+      .filter((value: number) => {
+        return typeof value === "number" && !isNaN(value);
+      });
+
+    return {
+      alias: alias,
+      values: values,
+    };
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -0,0 +1,439 @@
+import logger from "../Logger";
+import VMUtil from "../VM/VMAPI";
+import APIRequestCriteria from "./Criteria/APIRequestCriteria";
+import CustomCodeMonitoringCriteria from "./Criteria/CustomCodeMonitorCriteria";
+import IncomingRequestCriteria from "./Criteria/IncomingRequestCriteria";
+import SSLMonitorCriteria from "./Criteria/SSLMonitorCriteria";
+import ServerMonitorCriteria from "./Criteria/ServerMonitorCriteria";
+import SyntheticMonitoringCriteria from "./Criteria/SyntheticMonitor";
+import LogMonitorCriteria from "./Criteria/LogMonitorCriteria";
+import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
+import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
+import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
+import DataToProcess from "./DataToProcess";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import MonitorEvaluationSummary, {
+  MonitorEvaluationCriteriaResult,
+  MonitorEvaluationEvent,
+  MonitorEvaluationFilterResult,
+} from "../../../Types/Monitor/MonitorEvaluationSummary";
+import ProbeApiIngestResponse from "../../../Types/Probe/ProbeApiIngestResponse";
+import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
+import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import { CheckOn, CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
+import OneUptimeDate from "../../../Types/Date";
+import { JSONObject } from "../../../Types/JSON";
+import Typeof from "../../../Types/Typeof";
+import ReturnResult from "../../../Types/IsolatedVM/ReturnResult";
+
+export default class MonitorCriteriaEvaluator {
+  public static async processMonitorStep(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+    probeApiIngestResponse: ProbeApiIngestResponse;
+    evaluationSummary: MonitorEvaluationSummary;
+  }): Promise<ProbeApiIngestResponse> {
+    const criteria: MonitorCriteria | undefined =
+      input.monitorStep.data?.monitorCriteria;
+
+    if (!criteria || !criteria.data) {
+      return input.probeApiIngestResponse;
+    }
+
+    for (const criteriaInstance of criteria.data.monitorCriteriaInstanceArray) {
+      const criteriaResult: MonitorEvaluationCriteriaResult = {
+        criteriaId: criteriaInstance.data?.id,
+        criteriaName: criteriaInstance.data?.name,
+        filterCondition:
+          criteriaInstance.data?.filterCondition || FilterCondition.All,
+        met: false,
+        message: "",
+        filters: [],
+      };
+
+      input.evaluationSummary.criteriaResults.push(criteriaResult);
+
+      const rootCause: string | null =
+        await MonitorCriteriaEvaluator.processMonitorCriteriaInstance({
+          dataToProcess: input.dataToProcess,
+          monitorStep: input.monitorStep,
+          monitor: input.monitor,
+          probeApiIngestResponse: input.probeApiIngestResponse,
+          criteriaInstance: criteriaInstance,
+          criteriaResult: criteriaResult,
+        });
+
+      if (!criteriaResult.message) {
+        criteriaResult.message = criteriaResult.met
+          ? "Criteria met."
+          : "Criteria was not met.";
+      }
+
+      const criteriaEvent: MonitorEvaluationEvent = {
+        type: criteriaResult.met ? "criteria-met" : "criteria-not-met",
+        title: `${criteriaResult.met ? "Criteria met" : "Criteria not met"}: ${criteriaResult.criteriaName || "Unnamed criteria"}`,
+        message: criteriaResult.message,
+        relatedCriteriaId: criteriaResult.criteriaId,
+        at: OneUptimeDate.getCurrentDate(),
+      };
+
+      input.evaluationSummary.events.push(criteriaEvent);
+
+      if (rootCause) {
+        input.probeApiIngestResponse.criteriaMetId = criteriaInstance.data?.id;
+        input.probeApiIngestResponse.rootCause = `
+**Created because the following criteria was met**: 
+
+**Criteria Name**: ${criteriaInstance.data?.name}
+`;
+
+        input.probeApiIngestResponse.rootCause += `
+**Filter Conditions Met**: ${rootCause}
+`;
+
+        if ((input.dataToProcess as ProbeMonitorResponse).failureCause) {
+          input.probeApiIngestResponse.rootCause += `
+**Cause**: ${(input.dataToProcess as ProbeMonitorResponse).failureCause || ""}
+`;
+        }
+        break;
+      }
+    }
+
+    return input.probeApiIngestResponse;
+  }
+
+  private static async processMonitorCriteriaInstance(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+    probeApiIngestResponse: ProbeApiIngestResponse;
+    criteriaInstance: MonitorCriteriaInstance;
+    criteriaResult: MonitorEvaluationCriteriaResult;
+  }): Promise<string | null> {
+    return MonitorCriteriaEvaluator.isMonitorInstanceCriteriaFiltersMet({
+      dataToProcess: input.dataToProcess,
+      monitorStep: input.monitorStep,
+      monitor: input.monitor,
+      probeApiIngestResponse: input.probeApiIngestResponse,
+      criteriaInstance: input.criteriaInstance,
+      criteriaResult: input.criteriaResult,
+    });
+  }
+
+  private static async isMonitorInstanceCriteriaFiltersMet(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+    probeApiIngestResponse: ProbeApiIngestResponse;
+    criteriaInstance: MonitorCriteriaInstance;
+    criteriaResult: MonitorEvaluationCriteriaResult;
+  }): Promise<string | null> {
+    const filterCondition: FilterCondition =
+      input.criteriaInstance.data?.filterCondition || FilterCondition.All;
+
+    const matchedFilterMessages: Array<string> = [];
+    let hasMatch: boolean = false;
+    let allFiltersMet: boolean = true;
+
+    for (const criteriaFilter of input.criteriaInstance.data?.filters || []) {
+      const rootCause: string | null =
+        await MonitorCriteriaEvaluator.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          monitorStep: input.monitorStep,
+          monitor: input.monitor,
+          probeApiIngestResponse: input.probeApiIngestResponse,
+          criteriaInstance: input.criteriaInstance,
+          criteriaFilter: criteriaFilter,
+        });
+
+      const didMeetCriteria: boolean = Boolean(rootCause);
+
+      const filterMessage: string =
+        MonitorCriteriaMessageBuilder.buildCriteriaFilterMessage({
+          monitor: input.monitor,
+          criteriaFilter: criteriaFilter,
+          dataToProcess: input.dataToProcess,
+          monitorStep: input.monitorStep,
+          didMeetCriteria: didMeetCriteria,
+          matchMessage: rootCause,
+        });
+
+      const filterSummary: MonitorEvaluationFilterResult = {
+        checkOn: criteriaFilter.checkOn,
+        filterType: criteriaFilter.filterType,
+        value: criteriaFilter.value,
+        met: didMeetCriteria,
+        message: filterMessage,
+      };
+
+      input.criteriaResult.filters.push(filterSummary);
+
+      if (didMeetCriteria) {
+        hasMatch = true;
+        matchedFilterMessages.push(filterMessage);
+      } else if (filterCondition === FilterCondition.All) {
+        allFiltersMet = false;
+      }
+    }
+
+    if (filterCondition === FilterCondition.All) {
+      if (allFiltersMet && input.criteriaResult.filters.length > 0) {
+        let message: string = "All filters met.";
+
+        if (matchedFilterMessages.length > 0) {
+          message += matchedFilterMessages
+            .map((item: string) => {
+              return `\n- ${item}`;
+            })
+            .join("");
+        }
+
+        input.criteriaResult.met = true;
+        input.criteriaResult.message = message;
+
+        return message;
+      }
+
+      input.criteriaResult.met = false;
+      input.criteriaResult.message =
+        "One or more filters did not meet the configured conditions.";
+
+      return null;
+    }
+
+    if (filterCondition === FilterCondition.Any) {
+      if (hasMatch) {
+        const firstMatch: string =
+          matchedFilterMessages[0] ||
+          "At least one filter met the configured condition.";
+
+        input.criteriaResult.met = true;
+        input.criteriaResult.message = firstMatch;
+
+        return firstMatch;
+      }
+
+      input.criteriaResult.met = false;
+      input.criteriaResult.message =
+        "No filters met the configured conditions.";
+
+      return null;
+    }
+
+    return null;
+  }
+
+  private static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+    probeApiIngestResponse: ProbeApiIngestResponse;
+    criteriaInstance: MonitorCriteriaInstance;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    if (input.criteriaFilter.checkOn === CheckOn.JavaScriptExpression) {
+      let storageMap: JSONObject = {};
+
+      if (
+        input.monitor.monitorType === MonitorType.API ||
+        input.monitor.monitorType === MonitorType.Website
+      ) {
+        let responseBody: JSONObject | null = null;
+        try {
+          responseBody = JSON.parse(
+            ((input.dataToProcess as ProbeMonitorResponse)
+              .responseBody as string) || "{}",
+          );
+        } catch (err) {
+          logger.error(err);
+          responseBody = (input.dataToProcess as ProbeMonitorResponse)
+            .responseBody as JSONObject;
+        }
+
+        if (
+          typeof responseBody === Typeof.String &&
+          responseBody?.toString() === ""
+        ) {
+          responseBody = {};
+        }
+
+        storageMap = {
+          responseBody: responseBody,
+          responseHeaders: (input.dataToProcess as ProbeMonitorResponse)
+            .responseHeaders,
+          responseStatusCode: (input.dataToProcess as ProbeMonitorResponse)
+            .responseCode,
+          responseTimeInMs: (input.dataToProcess as ProbeMonitorResponse)
+            .responseTimeInMs,
+          isOnline: (input.dataToProcess as ProbeMonitorResponse).isOnline,
+        };
+      }
+
+      if (input.monitor.monitorType === MonitorType.IncomingRequest) {
+        storageMap = {
+          requestBody: (input.dataToProcess as IncomingMonitorRequest)
+            .requestBody,
+          requestHeaders: (input.dataToProcess as IncomingMonitorRequest)
+            .requestHeaders,
+        };
+      }
+
+      let expression: string = input.criteriaFilter.value as string;
+      expression = VMUtil.replaceValueInPlace(storageMap, expression, false);
+
+      const code: string = `return Boolean(${expression});`;
+      let result: ReturnResult | null = null;
+
+      try {
+        result = await VMUtil.runCodeInSandbox({
+          code: code,
+          options: {
+            args: {},
+          },
+        });
+      } catch (err) {
+        logger.error(err);
+        return null;
+      }
+
+      if (result && result.returnValue) {
+        return `JavaScript Expression - ${expression} - evaluated to true.`;
+      }
+
+      return null;
+    }
+
+    if (
+      input.monitor.monitorType === MonitorType.API ||
+      input.monitor.monitorType === MonitorType.Website ||
+      input.monitor.monitorType === MonitorType.IP ||
+      input.monitor.monitorType === MonitorType.Ping ||
+      input.monitor.monitorType === MonitorType.Port
+    ) {
+      const apiRequestCriteriaResult: string | null =
+        await APIRequestCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (apiRequestCriteriaResult) {
+        return apiRequestCriteriaResult;
+      }
+    }
+
+    if (
+      input.monitor.monitorType === MonitorType.CustomJavaScriptCode &&
+      (input.dataToProcess as ProbeMonitorResponse).customCodeMonitorResponse
+    ) {
+      const criteriaResult: string | null =
+        await CustomCodeMonitoringCriteria.isMonitorInstanceCriteriaFilterMet({
+          monitorResponse: (input.dataToProcess as ProbeMonitorResponse)
+            .customCodeMonitorResponse!,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (criteriaResult) {
+        return criteriaResult;
+      }
+    }
+
+    if (
+      input.monitor.monitorType === MonitorType.SyntheticMonitor &&
+      (input.dataToProcess as ProbeMonitorResponse).syntheticMonitorResponse
+    ) {
+      const criteriaResult: string | null =
+        await SyntheticMonitoringCriteria.isMonitorInstanceCriteriaFilterMet({
+          monitorResponse:
+            (input.dataToProcess as ProbeMonitorResponse)
+              .syntheticMonitorResponse || [],
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (criteriaResult) {
+        return criteriaResult;
+      }
+    }
+
+    if (input.monitor.monitorType === MonitorType.IncomingRequest) {
+      const incomingRequestResult: string | null =
+        await IncomingRequestCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (incomingRequestResult) {
+        return incomingRequestResult;
+      }
+    }
+
+    if (input.monitor.monitorType === MonitorType.SSLCertificate) {
+      const sslMonitorResult: string | null =
+        await SSLMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (sslMonitorResult) {
+        return sslMonitorResult;
+      }
+    }
+
+    if (input.monitor.monitorType === MonitorType.Server) {
+      const serverMonitorResult: string | null =
+        await ServerMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (serverMonitorResult) {
+        return serverMonitorResult;
+      }
+    }
+
+    if (input.monitor.monitorType === MonitorType.Logs) {
+      const logMonitorResult: string | null =
+        await LogMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (logMonitorResult) {
+        return logMonitorResult;
+      }
+    }
+
+    if (input.monitor.monitorType === MonitorType.Metrics) {
+      const metricMonitorResult: string | null =
+        await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+          monitorStep: input.monitorStep,
+        });
+
+      if (metricMonitorResult) {
+        return metricMonitorResult;
+      }
+    }
+
+    if (input.monitor.monitorType === MonitorType.Traces) {
+      const traceMonitorResult: string | null =
+        await TraceMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (traceMonitorResult) {
+        return traceMonitorResult;
+      }
+    }
+
+    return null;
+  }
+}