@oneuptime/common 12.0.13 → 12.0.15

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -37,10 +37,10 @@ import MonitorSummarySnapshot from "../../../Types/Monitor/MonitorSummarySnapsho
 import MonitorSummarySnapshotUtil from "../../../Utils/Monitor/MonitorSummarySnapshotUtil";
 import { IncidentMemberRoleAssignment } from "../../../Types/Monitor/CriteriaIncident";
 import { PerSeriesCriteriaMatch } from "../../../Types/Probe/ProbeApiIngestResponse";
-import MonitorClusterContextUtil, {
-  MonitorClusterContext,
-} from "./MonitorClusterContext";
-import SeriesResourceLinker from "./SeriesResourceLinker";
+import MonitorResourceContextUtil from "./MonitorResourceContext";
+import SeriesResourceLinker, {
+  SeriesResolvedResourceIds,
+} from "./SeriesResourceLinker";
 
 export default class MonitorIncident {
   @CaptureSpan()
@@ -364,15 +364,17 @@ export default class MonitorIncident {
     }
 
     /*
-     * Proxmox/Ceph monitors: resolve the monitored cluster once per
-     * evaluation (lookup-only, from the step config's clusterIdentifier)
-     * so every incident created below is attached to it. Series labels
-     * cannot supply this — they carry datapoint labels (`id`,
-     * `ceph_daemon`, `pool_id`), not cluster identity, and ungrouped
-     * templates have no series at all. No-op for other monitor types.
+     * Resolve the resources this monitor's own config names — its host,
+     * cluster, fleet, telemetry services, or the resource its metric
+     * filters scope it to — once per evaluation, so every incident
+     * created below is attached to them. Series labels cannot supply
+     * this: they only exist for grouped criteria, and most monitors
+     * (every shipped Host/Docker/Podman template, all Logs/Traces/
+     * Exceptions monitors) are ungrouped. No-op, and no round-trip, for
+     * monitor types whose config names no resource.
      */
-    const clusterContext: MonitorClusterContext =
-      await MonitorClusterContextUtil.resolveClusterContextForMonitor({
+    const resourceContext: SeriesResolvedResourceIds =
+      await MonitorResourceContextUtil.resolveResourceContextForMonitor({
         monitor: input.monitor,
       });
 
@@ -656,19 +658,20 @@ export default class MonitorIncident {
             model: incident,
             seriesLabels,
             projectId: input.monitor.projectId!,
+            monitorType: input.monitor.monitorType,
           });
         }
 
         /*
-         * Deterministic Proxmox/Ceph cluster link from the monitor's
-         * step config (resolved once above). Runs for both grouped and
-         * ungrouped incidents and merges with anything the series-label
-         * path resolved, so the per-cluster Activity tabs always see
+         * Deterministic resource link from the monitor's step config
+         * (resolved once above). Runs for both grouped and ungrouped
+         * incidents and merges with anything the series-label path
+         * resolved, so the per-resource Activity tabs always see
          * monitor-created incidents.
          */
-        SeriesResourceLinker.attachClusterContext({
+        SeriesResourceLinker.attachResolvedResources({
           model: incident,
-          clusterContext,
+          resolved: resourceContext,
         });
 
         incident.onCallDutyPolicies =

package/Server/Utils/Monitor/MonitorResource.ts

@@ -24,6 +24,7 @@ import MonitorType, {
 } from "../../../Types/Monitor/MonitorType";
 import ServerMonitorResponse from "../../../Types/Monitor/ServerMonitor/ServerMonitorResponse";
 import ObjectID from "../../../Types/ObjectID";
+import { JSONObject } from "../../../Types/JSON";
 import ProbeApiIngestResponse from "../../../Types/Probe/ProbeApiIngestResponse";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
@@ -141,6 +142,13 @@ export default class MonitorResourceUtil {
         _id: true,
         name: true,
         minimumProbeAgreement: true,
+        /*
+         * How often this monitor is checked. Over-time criteria filters need
+         * it to work out how many samples a fully covered evaluation window
+         * should hold - without it a monitor that has only just started
+         * looks the same as one whose whole window is breaching.
+         */
+        monitoringInterval: true,
         /*
          * Recorded as oneuptime.label.* / oneuptime.customField.* attributes on
          * every monitor metric this result produces, so response time and
@@ -737,6 +745,7 @@ export default class MonitorResourceUtil {
             monitorStep: monitorStep,
             currentCriteriaMetId: response.criteriaMetId || null,
             currentRootCause: response.rootCause || null,
+            currentProbeId: (dataToProcess as ProbeMonitorResponse).probeId,
             monitorProbes: monitorProbesForMonitor || undefined,
           });
 
@@ -1238,12 +1247,115 @@ export default class MonitorResourceUtil {
     }
   }
 
+  /**
+   * Turn a probe response read back out of MonitorProbe.lastMonitoringLog
+   * into one the criteria evaluators can actually use.
+   *
+   * The column stores `JSON.parse(JSON.stringify(response))`, which turns
+   * every ObjectID into a plain `{ _type: "ObjectID", value: "..." }` object
+   * and every Date into a string. Those plain objects are not `instanceof
+   * ObjectID`, so the analytics query builder binds them as-is and the
+   * "evaluate over time" lookup silently matches zero rows - which used to
+   * be indistinguishable from "this monitor has no history" and sent the
+   * evaluator down its instantaneous-value fallback. The result was a
+   * decision that disagreed with the evaluation summary shown beside it.
+   */
+  public static hydrateStoredProbeResponse(
+    probeResponse: ProbeMonitorResponse,
+  ): ProbeMonitorResponse {
+    const hydrated: ProbeMonitorResponse = {
+      ...probeResponse,
+    };
+
+    const toObjectID: (value: unknown) => ObjectID | undefined = (
+      value: unknown,
+    ): ObjectID | undefined => {
+      if (!value) {
+        return undefined;
+      }
+
+      if (value instanceof ObjectID) {
+        return value;
+      }
+
+      if (typeof value === "string") {
+        return new ObjectID(value);
+      }
+
+      if (typeof value === "object") {
+        const asJson: JSONObject = value as JSONObject;
+
+        if (asJson["value"]) {
+          return new ObjectID(asJson["value"].toString());
+        }
+      }
+
+      return undefined;
+    };
+
+    const toDate: (value: unknown) => Date | undefined = (
+      value: unknown,
+    ): Date | undefined => {
+      if (!value) {
+        return undefined;
+      }
+
+      if (value instanceof Date) {
+        return value;
+      }
+
+      const parsed: Date = new Date(value as string);
+
+      return isNaN(parsed.getTime()) ? undefined : parsed;
+    };
+
+    const projectId: ObjectID | undefined = toObjectID(probeResponse.projectId);
+    if (projectId) {
+      hydrated.projectId = projectId;
+    }
+
+    const monitorId: ObjectID | undefined = toObjectID(probeResponse.monitorId);
+    if (monitorId) {
+      hydrated.monitorId = monitorId;
+    }
+
+    const monitorStepId: ObjectID | undefined = toObjectID(
+      probeResponse.monitorStepId,
+    );
+    if (monitorStepId) {
+      hydrated.monitorStepId = monitorStepId;
+    }
+
+    const probeId: ObjectID | undefined = toObjectID(probeResponse.probeId);
+    if (probeId) {
+      hydrated.probeId = probeId;
+    }
+
+    const monitoredAt: Date | undefined = toDate(probeResponse.monitoredAt);
+    if (monitoredAt) {
+      hydrated.monitoredAt = monitoredAt;
+    }
+
+    const ingestedAt: Date | undefined = toDate(probeResponse.ingestedAt);
+    if (ingestedAt) {
+      hydrated.ingestedAt = ingestedAt;
+    }
+
+    return hydrated;
+  }
+
   @CaptureSpan()
   private static async checkProbeAgreement(input: {
     monitor: Monitor;
     monitorStep: MonitorStep;
     currentCriteriaMetId: string | null;
     currentRootCause: string | null;
+    /*
+     * Probe that produced the result being handled right now. Its verdict is
+     * already in currentCriteriaMetId / currentRootCause, so it is reused
+     * rather than recomputed - see the loop below.
+     */
+    currentProbeId?: ObjectID | undefined;
     /*
      * Pre-fetched MonitorProbe rows for this monitor (probeId, isEnabled,
      * lastMonitoringLog, probe.name/connectionStatus). The probe-result hot
@@ -1342,30 +1454,58 @@ export default class MonitorResourceUtil {
         continue;
       }
 
-      // Evaluate this probe's response against criteria
-      const tempResponse: ProbeApiIngestResponse = {
-        monitorId: monitor.id!,
-        criteriaMetId: undefined,
-        rootCause: null,
-      };
+      let evaluatedCriteriaMetId: string | undefined = undefined;
+      let evaluatedRootCause: string | null = null;
 
-      const tempEvaluationSummary: MonitorEvaluationSummary = {
-        evaluatedAt: OneUptimeDate.getCurrentDate(),
-        criteriaResults: [],
-        events: [],
-      };
+      const isCurrentProbe: boolean = Boolean(
+        input.currentProbeId &&
+          monitorProbe.probeId?.toString() === input.currentProbeId.toString(),
+      );
 
-      const evaluatedResponse: ProbeApiIngestResponse =
-        await MonitorCriteriaEvaluator.processMonitorStep({
-          dataToProcess: probeResponse as DataToProcess,
-          monitorStep: monitorStep,
-          monitor: monitor,
-          probeApiIngestResponse: tempResponse,
-          evaluationSummary: tempEvaluationSummary,
-        });
+      if (isCurrentProbe) {
+        /*
+         * The probe whose result we are handling right now was already
+         * evaluated by the caller, and that evaluation is the one the user
+         * sees in the evaluation summary. Re-running it here would evaluate
+         * a *different* window for any "evaluate over time" filter - seconds
+         * have passed, and this pass reads the payload back out of
+         * lastMonitoringLog rather than using the live object. That is how
+         * an incident could be created citing a criteria the summary right
+         * next to it reported as not met.
+         */
+        evaluatedCriteriaMetId = currentCriteriaMetId || undefined;
+        evaluatedRootCause = currentRootCause;
+      } else {
+        // Evaluate this probe's response against criteria
+        const tempResponse: ProbeApiIngestResponse = {
+          monitorId: monitor.id!,
+          criteriaMetId: undefined,
+          rootCause: null,
+        };
+
+        const tempEvaluationSummary: MonitorEvaluationSummary = {
+          evaluatedAt: OneUptimeDate.getCurrentDate(),
+          criteriaResults: [],
+          events: [],
+        };
+
+        const evaluatedResponse: ProbeApiIngestResponse =
+          await MonitorCriteriaEvaluator.processMonitorStep({
+            dataToProcess: MonitorResourceUtil.hydrateStoredProbeResponse(
+              probeResponse,
+            ) as DataToProcess,
+            monitorStep: monitorStep,
+            monitor: monitor,
+            probeApiIngestResponse: tempResponse,
+            evaluationSummary: tempEvaluationSummary,
+          });
+
+        evaluatedCriteriaMetId = evaluatedResponse.criteriaMetId;
+        evaluatedRootCause = evaluatedResponse.rootCause;
+      }
 
       // Record the result
-      const criteriaKey: string = evaluatedResponse.criteriaMetId || "none";
+      const criteriaKey: string = evaluatedCriteriaMetId || "none";
       const existing:
         | { count: number; rootCause: string | null; probeNames: Array<string> }
         | undefined = criteriaAgreements.get(criteriaKey);
@@ -1379,7 +1519,7 @@ export default class MonitorResourceUtil {
       } else {
         criteriaAgreements.set(criteriaKey, {
           count: 1,
-          rootCause: evaluatedResponse.rootCause,
+          rootCause: evaluatedRootCause,
           probeNames: [probeName],
         });
       }

package/Server/Utils/Monitor/MonitorResourceContext.ts

@@ -0,0 +1,107 @@
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import logger from "../Logger";
+import MonitorStepResourceIdentity from "./MonitorStepResourceIdentity";
+import { SeriesResourceRefs } from "./SeriesResourceLabels";
+import SeriesResourceLinker, {
+  SeriesResolvedResourceIds,
+} from "./SeriesResourceLinker";
+
+/*
+ * Incidents and alerts created by a monitor must be attached to the
+ * resources that monitor watches — the per-resource Activity pages, the
+ * SideMenu badge counts, the "Affected Resources" card, the affected-
+ * resources filter, and resource owner/label inheritance all query those
+ * relations on Incident/Alert.
+ *
+ * Series labels cannot supply that identity on their own. They exist
+ * only when the criteria is GROUPED, and most monitors are not: every
+ * shipped Host / Docker / Podman / RUM template is ungrouped, the
+ * Kubernetes templates group by node/pod (never by cluster), and
+ * Logs / Traces / Exceptions monitors have no series concept at all. An
+ * ungrouped monitor therefore linked nothing, which is why a metric
+ * monitor scoped to one service with
+ * `oneuptime.service.name = checkout-api` opened alerts that showed "No
+ * resources affected".
+ *
+ * The deterministic source is the monitor's own step config, which
+ * always carries whatever the user picked when they built the monitor:
+ * a hostIdentifier, a clusterIdentifier, a fleetIdentifier, a set of
+ * telemetryServiceIds, or a metric attribute filter. This module reads
+ * it once per evaluation and resolves it to real rows.
+ *
+ * This supersedes the old MonitorClusterContext, which did the same
+ * thing for exactly four cluster types (Proxmox / Ceph / Docker Swarm /
+ * IoT) with a hand-rolled findOneBy per identifier.
+ */
+export default class MonitorResourceContextUtil {
+  /*
+   * Resolve the resource rows the monitor's configuration names.
+   *
+   * Lookup-only — row creation belongs to ingest discovery
+   * (findOrCreateByName); a monitor pointing at a host that never sent
+   * data simply links nothing. Lookups are ALWAYS project-scoped:
+   * `isRoot` bypasses row-level access control, so a stale or hostile
+   * identifier must never be able to pull a row in from another tenant.
+   *
+   * Returns empty for every monitor type whose config names no resource
+   * (Website, API, Ping, Synthetic, ...) without touching the database.
+   */
+  public static async resolveResourceContextForMonitor(input: {
+    monitor: Monitor;
+  }): Promise<SeriesResolvedResourceIds> {
+    const empty: SeriesResolvedResourceIds = this.emptyContext();
+
+    if (!input.monitor.projectId) {
+      return empty;
+    }
+
+    /*
+     * Resource linking is best-effort context — a failure must never
+     * block incident/alert creation, which runs inside the probe and
+     * telemetry queue workers where a throw retries the whole job
+     * forever. The EXTRACTION is inside the try as well as the lookup:
+     * it reads free-form, unvalidated step JSON, so a monitor saved
+     * through the API or an import can hand it a shape it cannot parse.
+     */
+    try {
+      const refs: SeriesResourceRefs =
+        MonitorStepResourceIdentity.extractResourceRefsFromMonitor({
+          monitor: input.monitor,
+        });
+
+      if (MonitorStepResourceIdentity.isEmpty(refs)) {
+        return empty;
+      }
+
+      return await SeriesResourceLinker.resolveResourceRefs({
+        refs: refs,
+        projectId: input.monitor.projectId,
+        /*
+         * The identifiers here were typed by a user into the monitor
+         * form, while the rows' names were stamped by an agent at
+         * ingest; the two legitimately differ by case.
+         */
+        nameMatch: "caseInsensitive",
+      });
+    } catch (err) {
+      logger.error(
+        `Failed to resolve affected resources for monitor ${input.monitor.id?.toString()}: ${err}`,
+      );
+      return empty;
+    }
+  }
+
+  public static emptyContext(): SeriesResolvedResourceIds {
+    return {
+      hostIds: [],
+      dockerHostIds: [],
+      podmanHostIds: [],
+      kubernetesClusterIds: [],
+      serviceIds: [],
+      proxmoxClusterIds: [],
+      cephClusterIds: [],
+      dockerSwarmClusterIds: [],
+      iotFleetIds: [],
+    };
+  }
+}