@oneuptime/common 8.0.5514 → 8.0.5544

package/Server/Utils/Monitor/MonitorCriteriaExpectationBuilder.ts

@@ -0,0 +1,141 @@
+import {
+  CriteriaFilter,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+
+export default class MonitorCriteriaExpectationBuilder {
+  public static getCriteriaFilterDescription(
+    criteriaFilter: CriteriaFilter,
+  ): string {
+    const parts: Array<string> = [criteriaFilter.checkOn];
+
+    if (criteriaFilter.filterType) {
+      parts.push(criteriaFilter.filterType);
+    }
+
+    if (criteriaFilter.value !== undefined && criteriaFilter.value !== null) {
+      parts.push(String(criteriaFilter.value));
+    }
+
+    return parts.join(" ").trim();
+  }
+
+  public static describeCriteriaExpectation(
+    criteriaFilter: CriteriaFilter,
+  ): string | null {
+    if (!criteriaFilter.filterType) {
+      return null;
+    }
+
+    let expectation: string;
+
+    const value: string | number | undefined = criteriaFilter.value;
+
+    switch (criteriaFilter.filterType) {
+      case FilterType.GreaterThan:
+        expectation = `to be greater than ${value}`;
+        break;
+      case FilterType.GreaterThanOrEqualTo:
+        expectation = `to be greater than or equal to ${value}`;
+        break;
+      case FilterType.LessThan:
+        expectation = `to be less than ${value}`;
+        break;
+      case FilterType.LessThanOrEqualTo:
+        expectation = `to be less than or equal to ${value}`;
+        break;
+      case FilterType.EqualTo:
+        expectation = `to equal ${value}`;
+        break;
+      case FilterType.NotEqualTo:
+        expectation = `to not equal ${value}`;
+        break;
+      case FilterType.Contains:
+        expectation = `to contain ${value}`;
+        break;
+      case FilterType.NotContains:
+        expectation = `to not contain ${value}`;
+        break;
+      case FilterType.StartsWith:
+        expectation = `to start with ${value}`;
+        break;
+      case FilterType.EndsWith:
+        expectation = `to end with ${value}`;
+        break;
+      case FilterType.IsEmpty:
+        expectation = "to be empty";
+        break;
+      case FilterType.IsNotEmpty:
+        expectation = "to not be empty";
+        break;
+      case FilterType.True:
+        expectation = "to be true";
+        break;
+      case FilterType.False:
+        expectation = "to be false";
+        break;
+      case FilterType.IsExecuting:
+        expectation = "to be executing";
+        break;
+      case FilterType.IsNotExecuting:
+        expectation = "to not be executing";
+        break;
+      case FilterType.RecievedInMinutes:
+        expectation = value
+          ? `to receive a heartbeat within ${value} minutes`
+          : "to receive a heartbeat within the configured window";
+        break;
+      case FilterType.NotRecievedInMinutes:
+        expectation = value
+          ? `to miss a heartbeat for at least ${value} minutes`
+          : "to miss a heartbeat within the configured window";
+        break;
+      case FilterType.EvaluatesToTrue:
+        expectation = "to evaluate to true";
+        break;
+      default:
+        expectation = `${criteriaFilter.filterType}${value ? ` ${value}` : ""}`;
+        break;
+    }
+
+    const evaluationWindow: string | null =
+      MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+        criteriaFilter,
+      );
+
+    if (evaluationWindow) {
+      expectation += ` ${evaluationWindow}`;
+    }
+
+    return expectation.trim();
+  }
+
+  public static getEvaluationWindowDescription(
+    criteriaFilter: CriteriaFilter,
+  ): string | null {
+    const parts: Array<string> = [];
+
+    if (
+      criteriaFilter.eveluateOverTime &&
+      criteriaFilter.evaluateOverTimeOptions?.timeValueInMinutes
+    ) {
+      parts.push(
+        `over the last ${criteriaFilter.evaluateOverTimeOptions.timeValueInMinutes} minutes`,
+      );
+    }
+
+    const aggregation: string | undefined =
+      criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+      criteriaFilter.metricMonitorOptions?.metricAggregationType;
+
+    if (aggregation) {
+      parts.push(`using ${aggregation.toLowerCase()}`);
+    }
+
+    if (!parts.length) {
+      return null;
+    }
+
+    return parts.join(" ");
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaMessageBuilder.ts

@@ -0,0 +1,88 @@
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import DataToProcess from "./DataToProcess";
+import { CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
+import MonitorCriteriaExpectationBuilder from "./MonitorCriteriaExpectationBuilder";
+import MonitorCriteriaObservationBuilder from "./MonitorCriteriaObservationBuilder";
+
+export default class MonitorCriteriaMessageBuilder {
+  public static buildCriteriaFilterMessage(input: {
+    monitor: Monitor;
+    criteriaFilter: CriteriaFilter;
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    didMeetCriteria: boolean;
+    matchMessage: string | null;
+  }): string {
+    if (input.matchMessage) {
+      return input.matchMessage;
+    }
+
+    if (input.didMeetCriteria) {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          input.criteriaFilter,
+        );
+
+      return `${description} condition met.`;
+    }
+
+    const failureMessage: string | null =
+      MonitorCriteriaMessageBuilder.buildCriteriaFilterFailureMessage({
+        monitor: input.monitor,
+        criteriaFilter: input.criteriaFilter,
+        dataToProcess: input.dataToProcess,
+        monitorStep: input.monitorStep,
+      });
+
+    if (failureMessage) {
+      return failureMessage;
+    }
+
+    const description: string =
+      MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+        input.criteriaFilter,
+      );
+
+    return `${description} condition was not met.`;
+  }
+
+  private static buildCriteriaFilterFailureMessage(input: {
+    monitor: Monitor;
+    criteriaFilter: CriteriaFilter;
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+  }): string | null {
+    const expectation: string | null =
+      MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+        input.criteriaFilter,
+      );
+
+    const observation: string | null =
+      MonitorCriteriaObservationBuilder.describeFilterObservation({
+        monitor: input.monitor,
+        criteriaFilter: input.criteriaFilter,
+        dataToProcess: input.dataToProcess,
+        monitorStep: input.monitorStep,
+      });
+
+    if (observation) {
+      if (expectation) {
+        return `${observation} (expected ${expectation}).`;
+      }
+
+      return `${observation}; configured filter was not met.`;
+    }
+
+    if (expectation) {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          input.criteriaFilter,
+        );
+
+      return `${description} did not satisfy the configured condition (${expectation}).`;
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaMessageFormatter.ts

@@ -0,0 +1,196 @@
+import logger from "../Logger";
+import BasicInfrastructureMetrics from "../../../Types/Infrastructure/BasicMetrics";
+import Typeof from "../../../Types/Typeof";
+import { ServerProcess } from "../../../Types/Monitor/ServerMonitor/ServerMonitorResponse";
+
+export default class MonitorCriteriaMessageFormatter {
+  public static formatNumber(
+    value: number | null | undefined,
+    options?: { maximumFractionDigits?: number },
+  ): string | null {
+    if (value === null || value === undefined || isNaN(value)) {
+      return null;
+    }
+
+    const fractionDigits: number =
+      options?.maximumFractionDigits !== undefined
+        ? options.maximumFractionDigits
+        : Math.abs(value) < 10
+          ? 2
+          : Math.abs(value) < 100
+            ? 1
+            : 0;
+
+    return value.toFixed(fractionDigits);
+  }
+
+  public static formatPercentage(
+    value: number | null | undefined,
+  ): string | null {
+    const formatted: string | null =
+      MonitorCriteriaMessageFormatter.formatNumber(value, {
+        maximumFractionDigits:
+          value !== null && value !== undefined && Math.abs(value) < 100
+            ? 1
+            : 0,
+      });
+
+    if (!formatted) {
+      return null;
+    }
+
+    return `${formatted}%`;
+  }
+
+  public static formatBytes(bytes: number | null | undefined): string | null {
+    if (bytes === null || bytes === undefined || isNaN(bytes)) {
+      return null;
+    }
+
+    const units: Array<string> = ["B", "KB", "MB", "GB", "TB", "PB"];
+    let value: number = bytes;
+    let index: number = 0;
+
+    while (value >= 1024 && index < units.length - 1) {
+      value = value / 1024;
+      index++;
+    }
+
+    const formatted: string | null =
+      MonitorCriteriaMessageFormatter.formatNumber(value, {
+        maximumFractionDigits: value >= 100 ? 0 : value >= 10 ? 1 : 2,
+      });
+
+    if (!formatted) {
+      return null;
+    }
+
+    return `${formatted} ${units[index]}`;
+  }
+
+  public static formatList(items: Array<string>, maxItems: number = 5): string {
+    if (!items.length) {
+      return "";
+    }
+
+    const trimmedItems: Array<string> = items.slice(0, maxItems);
+    const suffix: string =
+      items.length > maxItems ? `, +${items.length - maxItems} more` : "";
+
+    return `${trimmedItems.join(", ")} ${suffix}`.trim();
+  }
+
+  public static formatSnippet(text: string, maxLength: number = 120): string {
+    const sanitized: string = text.replace(/\s+/g, " ").trim();
+
+    if (sanitized.length <= maxLength) {
+      return sanitized;
+    }
+
+    return `${sanitized.slice(0, maxLength)}…`;
+  }
+
+  public static describeProcesses(
+    processes: Array<ServerProcess>,
+  ): string | null {
+    if (!processes.length) {
+      return null;
+    }
+
+    const processSummaries: Array<string> = processes.map(
+      (process: ServerProcess) => {
+        return `${process.name} (pid ${process.pid})`;
+      },
+    );
+
+    return MonitorCriteriaMessageFormatter.formatList(processSummaries);
+  }
+
+  public static computeDiskUsagePercent(
+    diskMetric: BasicInfrastructureMetrics["diskMetrics"][number],
+  ): number | null {
+    if (!diskMetric) {
+      return null;
+    }
+
+    if (
+      diskMetric.percentUsed !== undefined &&
+      diskMetric.percentUsed !== null &&
+      !isNaN(diskMetric.percentUsed)
+    ) {
+      return diskMetric.percentUsed;
+    }
+
+    if (
+      diskMetric.percentFree !== undefined &&
+      diskMetric.percentFree !== null &&
+      !isNaN(diskMetric.percentFree)
+    ) {
+      return 100 - diskMetric.percentFree;
+    }
+
+    if (diskMetric.total && diskMetric.used && diskMetric.total > 0) {
+      return (diskMetric.used / diskMetric.total) * 100;
+    }
+
+    return null;
+  }
+
+  public static summarizeNumericSeries(values: Array<number>): string | null {
+    if (!values.length) {
+      return null;
+    }
+
+    const latest: number | undefined = values[values.length - 1];
+
+    if (latest === undefined) {
+      return null;
+    }
+
+    const latestFormatted: string | null =
+      MonitorCriteriaMessageFormatter.formatNumber(latest, {
+        maximumFractionDigits: 2,
+      });
+
+    let summary: string = `latest ${latestFormatted ?? latest}`;
+
+    if (values.length > 1) {
+      const min: number = Math.min(...values);
+      const max: number = Math.max(...values);
+
+      const minFormatted: string | null =
+        MonitorCriteriaMessageFormatter.formatNumber(min, {
+          maximumFractionDigits: 2,
+        });
+      const maxFormatted: string | null =
+        MonitorCriteriaMessageFormatter.formatNumber(max, {
+          maximumFractionDigits: 2,
+        });
+
+      summary += ` (min ${minFormatted ?? min}, max ${maxFormatted ?? max})`;
+    }
+
+    summary += ` across ${values.length} data point${
+      values.length === 1 ? "" : "s"
+    }`;
+
+    return summary;
+  }
+
+  public static formatResultValue(value: unknown): string {
+    if (value === null || value === undefined) {
+      return "undefined";
+    }
+
+    if (typeof value === Typeof.Object) {
+      try {
+        return JSON.stringify(value);
+      } catch (err) {
+        logger.error(err);
+        return "[object]";
+      }
+    }
+
+    return value.toString();
+  }
+}