@oneuptime/common 14.0.1 → 14.0.2

package/Utils/Monitor/MonitorOverviewCriteriaUtil.ts

@@ -0,0 +1,188 @@
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../Types/Monitor/CriteriaFilter";
+import MonitorSteps from "../../Types/Monitor/MonitorSteps";
+
+/*
+ * Small, defensive reads of a monitor's criteria for the overview facts.
+ * Steps are user-authored JSON that has been through several schema
+ * versions, so every level is treated as possibly missing.
+ */
+
+interface StepLike {
+  data?:
+    | {
+        monitorCriteria?:
+          | {
+              data?:
+                | {
+                    monitorCriteriaInstanceArray?: Array<unknown> | undefined;
+                  }
+                | undefined;
+            }
+          | undefined;
+        networkDeviceMonitor?: { networkDeviceId?: unknown } | undefined;
+      }
+    | undefined;
+}
+
+interface CriteriaInstanceLike {
+  data?:
+    | {
+        filters?: Array<CriteriaFilter> | undefined;
+        isEnabled?: boolean | undefined;
+      }
+    | undefined;
+}
+
+const getSteps: (monitorSteps: MonitorSteps | undefined) => Array<StepLike> = (
+  monitorSteps: MonitorSteps | undefined,
+): Array<StepLike> => {
+  const steps: unknown = monitorSteps?.data?.monitorStepsInstanceArray;
+
+  if (!Array.isArray(steps)) {
+    return [];
+  }
+
+  return steps.filter((step: unknown) => {
+    return Boolean(step) && typeof step === "object";
+  }) as Array<StepLike>;
+};
+
+/*
+ * The filters of every criteria instance the server evaluates. Criteria that
+ * are switched off are skipped: the server does not evaluate them, so
+ * quoting them would promise an alert that never comes.
+ */
+const getEnabledFilters: (
+  monitorSteps: MonitorSteps | undefined,
+) => Array<CriteriaFilter> = (
+  monitorSteps: MonitorSteps | undefined,
+): Array<CriteriaFilter> => {
+  const enabledFilters: Array<CriteriaFilter> = [];
+
+  for (const step of getSteps(monitorSteps)) {
+    const instances: unknown =
+      step.data?.monitorCriteria?.data?.monitorCriteriaInstanceArray;
+
+    if (!Array.isArray(instances)) {
+      continue;
+    }
+
+    for (const rawInstance of instances) {
+      if (!rawInstance || typeof rawInstance !== "object") {
+        continue;
+      }
+
+      const instance: CriteriaInstanceLike =
+        rawInstance as CriteriaInstanceLike;
+
+      if (instance.data?.isEnabled === false) {
+        continue;
+      }
+
+      const filters: unknown = instance.data?.filters;
+
+      if (!Array.isArray(filters)) {
+        continue;
+      }
+
+      for (const filter of filters as Array<CriteriaFilter>) {
+        if (filter && typeof filter === "object") {
+          enabledFilters.push(filter);
+        }
+      }
+    }
+  }
+
+  return enabledFilters;
+};
+
+export default class MonitorOverviewCriteriaUtil {
+  /*
+   * The "missing heartbeat" window a heartbeat or inbound-email monitor
+   * alerts on, in minutes. With several such filters the smallest wins,
+   * because that is the one that fires first.
+   */
+  public static getMissingSignalMinutes(data: {
+    monitorSteps: MonitorSteps | undefined;
+    checkOn: CheckOn;
+  }): number | null {
+    let smallest: number | null = null;
+
+    for (const filter of getEnabledFilters(data.monitorSteps)) {
+      if (filter.checkOn !== data.checkOn) {
+        continue;
+      }
+
+      if (
+        filter.filterType !== FilterType.NotRecievedInMinutes &&
+        filter.filterType !== FilterType.RecievedInMinutes
+      ) {
+        continue;
+      }
+
+      const minutes: number =
+        typeof filter.value === "number"
+          ? filter.value
+          : Number(String(filter.value ?? "").trim() || NaN);
+
+      if (!Number.isFinite(minutes) || minutes <= 0) {
+        continue;
+      }
+
+      if (smallest === null || minutes < smallest) {
+        smallest = minutes;
+      }
+    }
+
+    return smallest;
+  }
+
+  /*
+   * Whether an enabled criteria filter checks on `checkOn`. A server
+   * monitor is only judged offline for a missing agent report when its
+   * criteria check "Is Online" (ServerMonitor/CheckOnlineStatus skips the
+   * rest).
+   */
+  public static hasFilterOn(data: {
+    monitorSteps: MonitorSteps | undefined;
+    checkOn: CheckOn;
+  }): boolean {
+    return getEnabledFilters(data.monitorSteps).some(
+      (filter: CriteriaFilter) => {
+        return filter.checkOn === data.checkOn;
+      },
+    );
+  }
+
+  public static getStepCount(monitorSteps: MonitorSteps | undefined): number {
+    return getSteps(monitorSteps).length;
+  }
+
+  /*
+   * The device the monitor alerts on, from the first step. Deliberately not
+   * Monitor.autoProvisionedNetworkDeviceId: that records which device
+   * created the monitor, and a user can point the step at another one.
+   */
+  public static getNetworkDeviceId(
+    monitorSteps: MonitorSteps | undefined,
+  ): string | null {
+    const id: unknown =
+      getSteps(monitorSteps)[0]?.data?.networkDeviceMonitor?.networkDeviceId;
+
+    if (typeof id === "string") {
+      return id.trim() || null;
+    }
+
+    if (id && typeof id === "object") {
+      const text: string = String(id).trim();
+
+      return text && text !== "[object Object]" ? text : null;
+    }
+
+    return null;
+  }
+}

package/Utils/Monitor/MonitorOverviewFamily.ts

@@ -0,0 +1,263 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import MonitorMetricType from "../../Types/Monitor/MonitorMetricType";
+import MonitorType from "../../Types/Monitor/MonitorType";
+import MonitorMetricTypeUtil from "./MonitorMetricType";
+
+/*
+ * The monitor overview groups the 34 monitor types into seven families that
+ * behave alike on the page: where the "last checked" time comes from, which
+ * facts the hero shows, which cards appear. Everything type-specific on the
+ * overview goes through this one switch, so a new MonitorType fails to
+ * compile here until somebody decides how its overview should look.
+ */
+
+export enum MonitorOverviewFamily {
+  // Run by probes on a schedule.
+  ProbeCheck = "ProbeCheck",
+  // Pushed to us: heartbeat requests and inbound email.
+  Heartbeat = "Heartbeat",
+  // Pushed by the server agent.
+  Agent = "Agent",
+  // Criteria evaluated by a worker over telemetry.
+  TelemetrySignal = "TelemetrySignal",
+  // Criteria evaluated by a worker over infrastructure metrics.
+  Infrastructure = "Infrastructure",
+  // Evaluated on every device poll and matching trap.
+  NetworkDevice = "NetworkDevice",
+  // No checks at all; people set the status.
+  Manual = "Manual",
+}
+
+export enum MonitorOverviewSetupKind {
+  HeartbeatUrl = "HeartbeatUrl",
+  InboundEmail = "InboundEmail",
+  ServerAgent = "ServerAgent",
+}
+
+export type MonitorOverviewSideCard = "probes" | "connection" | "manual";
+
+export type MonitorOverviewTelemetryPreview =
+  | "Logs"
+  | "Metrics"
+  | "Traces"
+  | "SecurityEvents";
+
+/*
+ * How many MonitorLog rows the overview reads to explain the latest verdict:
+ * one per probe for probe checks, the newest row for everything evaluated
+ * centrally, none for Manual (nothing is evaluated).
+ */
+export type MonitorOverviewEvaluationPolicy = "PerProbe" | "Latest" | "None";
+
+export interface MonitorOverviewLayout {
+  family: MonitorOverviewFamily;
+  responseTimeMetric: MonitorMetricType | null;
+  telemetryPreview: MonitorOverviewTelemetryPreview | null;
+  evaluationPolicy: MonitorOverviewEvaluationPolicy;
+  setupKind: MonitorOverviewSetupKind | null;
+  sideCard: MonitorOverviewSideCard | null;
+  summaryDescription: string | null;
+}
+
+export default class MonitorOverviewFamilyUtil {
+  public static getFamily(monitorType: MonitorType): MonitorOverviewFamily {
+    switch (monitorType) {
+      case MonitorType.API:
+      case MonitorType.Website:
+      case MonitorType.IP:
+      case MonitorType.Ping:
+      case MonitorType.Port:
+      case MonitorType.SSLCertificate:
+      case MonitorType.SyntheticMonitor:
+      case MonitorType.CustomJavaScriptCode:
+      case MonitorType.DNS:
+      case MonitorType.DNSSEC:
+      case MonitorType.Domain:
+      case MonitorType.SQLQuery:
+      case MonitorType.Database:
+      case MonitorType.ExternalStatusPage:
+        return MonitorOverviewFamily.ProbeCheck;
+
+      case MonitorType.IncomingRequest:
+      case MonitorType.IncomingEmail:
+        return MonitorOverviewFamily.Heartbeat;
+
+      case MonitorType.Server:
+        return MonitorOverviewFamily.Agent;
+
+      case MonitorType.Logs:
+      case MonitorType.Metrics:
+      case MonitorType.Traces:
+      case MonitorType.Exceptions:
+      case MonitorType.Profiles:
+      case MonitorType.SecurityEvents:
+        return MonitorOverviewFamily.TelemetrySignal;
+
+      case MonitorType.Kubernetes:
+      case MonitorType.Docker:
+      case MonitorType.Host:
+      case MonitorType.Podman:
+      case MonitorType.DockerSwarm:
+      case MonitorType.Proxmox:
+      case MonitorType.VMware:
+      case MonitorType.Ceph:
+      case MonitorType.IoTDevice:
+        return MonitorOverviewFamily.Infrastructure;
+
+      case MonitorType.NetworkDevice:
+        return MonitorOverviewFamily.NetworkDevice;
+
+      case MonitorType.Manual:
+        return MonitorOverviewFamily.Manual;
+
+      default: {
+        /*
+         * Compile-time guard: a MonitorType added without a case above makes
+         * this assignment a type error.
+         */
+        const unhandled: never = monitorType;
+        throw new BadDataException(
+          `Monitor type ${String(unhandled)} has no overview family.`,
+        );
+      }
+    }
+  }
+
+  public static getLayout(monitorType: MonitorType): MonitorOverviewLayout {
+    const family: MonitorOverviewFamily =
+      MonitorOverviewFamilyUtil.getFamily(monitorType);
+
+    return {
+      family: family,
+      responseTimeMetric: MonitorOverviewFamilyUtil.getResponseTimeMetric(
+        monitorType,
+        family,
+      ),
+      telemetryPreview:
+        MonitorOverviewFamilyUtil.getTelemetryPreview(monitorType),
+      evaluationPolicy: MonitorOverviewFamilyUtil.getEvaluationPolicy(family),
+      setupKind: MonitorOverviewFamilyUtil.getSetupKind(monitorType),
+      sideCard: MonitorOverviewFamilyUtil.getSideCard(family),
+      summaryDescription: MonitorOverviewFamilyUtil.getSummaryDescription(
+        monitorType,
+        family,
+      ),
+    };
+  }
+
+  /*
+   * The chart the response-time card draws. Scripted checks have no
+   * response, only a run time, so they get ExecutionTime. Read from the
+   * metric catalog rather than listed here, so the card only ever asks for
+   * a series the probe actually writes.
+   */
+  private static getResponseTimeMetric(
+    monitorType: MonitorType,
+    family: MonitorOverviewFamily,
+  ): MonitorMetricType | null {
+    if (family !== MonitorOverviewFamily.ProbeCheck) {
+      return null;
+    }
+
+    const metrics: Array<MonitorMetricType> =
+      MonitorMetricTypeUtil.getMonitorMetricTypesByMonitorType(monitorType);
+
+    if (metrics.includes(MonitorMetricType.ResponseTime)) {
+      return MonitorMetricType.ResponseTime;
+    }
+
+    if (metrics.includes(MonitorMetricType.ExecutionTime)) {
+      return MonitorMetricType.ExecutionTime;
+    }
+
+    return null;
+  }
+
+  private static getTelemetryPreview(
+    monitorType: MonitorType,
+  ): MonitorOverviewTelemetryPreview | null {
+    switch (monitorType) {
+      case MonitorType.Logs:
+        return "Logs";
+      case MonitorType.Metrics:
+        return "Metrics";
+      case MonitorType.Traces:
+        return "Traces";
+      case MonitorType.SecurityEvents:
+        return "SecurityEvents";
+      default:
+        return null;
+    }
+  }
+
+  private static getEvaluationPolicy(
+    family: MonitorOverviewFamily,
+  ): MonitorOverviewEvaluationPolicy {
+    if (family === MonitorOverviewFamily.ProbeCheck) {
+      return "PerProbe";
+    }
+
+    if (family === MonitorOverviewFamily.Manual) {
+      return "None";
+    }
+
+    return "Latest";
+  }
+
+  private static getSetupKind(
+    monitorType: MonitorType,
+  ): MonitorOverviewSetupKind | null {
+    switch (monitorType) {
+      case MonitorType.IncomingRequest:
+        return MonitorOverviewSetupKind.HeartbeatUrl;
+      case MonitorType.IncomingEmail:
+        return MonitorOverviewSetupKind.InboundEmail;
+      case MonitorType.Server:
+        return MonitorOverviewSetupKind.ServerAgent;
+      default:
+        return null;
+    }
+  }
+
+  private static getSideCard(
+    family: MonitorOverviewFamily,
+  ): MonitorOverviewSideCard | null {
+    switch (family) {
+      case MonitorOverviewFamily.ProbeCheck:
+        return "probes";
+      case MonitorOverviewFamily.Heartbeat:
+      case MonitorOverviewFamily.Agent:
+        return "connection";
+      case MonitorOverviewFamily.Manual:
+        return "manual";
+      default:
+        return null;
+    }
+  }
+
+  private static getSummaryDescription(
+    monitorType: MonitorType,
+    family: MonitorOverviewFamily,
+  ): string | null {
+    switch (family) {
+      case MonitorOverviewFamily.ProbeCheck:
+        return "What each probe saw on its most recent check.";
+      case MonitorOverviewFamily.Heartbeat:
+        return monitorType === MonitorType.IncomingEmail
+          ? "The most recent email and how the criteria judged it."
+          : "The most recent request and how the criteria judged it.";
+      case MonitorOverviewFamily.Agent:
+        return "What the agent sent in its most recent report.";
+      case MonitorOverviewFamily.TelemetrySignal:
+      case MonitorOverviewFamily.Infrastructure:
+        return "How the criteria judged the data on the most recent evaluation.";
+      case MonitorOverviewFamily.NetworkDevice:
+        return "How this monitor is evaluated.";
+      case MonitorOverviewFamily.Manual:
+        // Nothing is evaluated, so there is nothing to summarise.
+        return null;
+      default:
+        return null;
+    }
+  }
+}