@oneuptime/common 12.0.32 → 12.0.34

package/Server/Services/Index.ts

@@ -63,6 +63,8 @@ import NetworkDeviceLabelRuleService from "./NetworkDeviceLabelRuleService";
 import NetworkDeviceAutoImportRuleService from "./NetworkDeviceAutoImportRuleService";
 import NetworkDeviceOidTemplateService from "./NetworkDeviceOidTemplateService";
 import NetworkDeviceRoleService from "./NetworkDeviceRoleService";
+import NetworkAlertPolicyService from "./NetworkAlertPolicyService";
+import NetworkSnmpCredentialProfileService from "./NetworkSnmpCredentialProfileService";
 import NetworkDeviceDiscoveryScanService from "./NetworkDeviceDiscoveryScanService";
 import NetworkInterfaceService from "./NetworkInterfaceService";
 import NetworkSiteService from "./NetworkSiteService";
@@ -425,6 +427,9 @@ import IoTFleetLabelRuleService from "./IoTFleetLabelRuleService";
 import IoTFleetOwnerRuleService from "./IoTFleetOwnerRuleService";
 import IoTFleetOwnerTeamService from "./IoTFleetOwnerTeamService";
 import IoTFleetOwnerUserService from "./IoTFleetOwnerUserService";
+import UserNotificationEmailRollupItemService from "./UserNotificationEmailRollupItemService";
+import UserNotificationEmailRollupBatchService from "./UserNotificationEmailRollupBatchService";
+import UserNotificationEmailRollupSettingService from "./UserNotificationEmailRollupSettingService";
 
 const services: Array<BaseService> = [
   OnCallDutyPolicyTimeLogService,
@@ -510,6 +515,8 @@ const services: Array<BaseService> = [
   NetworkDeviceAutoImportRuleService,
   NetworkDeviceOidTemplateService,
   NetworkDeviceRoleService,
+  NetworkAlertPolicyService,
+  NetworkSnmpCredentialProfileService,
   NetworkDeviceDiscoveryScanService,
   NetworkInterfaceService,
   NetworkSiteService,
@@ -848,6 +855,9 @@ const services: Array<BaseService> = [
   ServerlessFunctionOwnerTeamService,
   ServerlessFunctionOwnerUserService,
   WebhookLogService,
+  UserNotificationEmailRollupItemService,
+  UserNotificationEmailRollupBatchService,
+  UserNotificationEmailRollupSettingService,
 ];
 
 export const AnalyticsServices: Array<

package/Server/Services/MetricService.ts

@@ -30,6 +30,8 @@ import {
 import { keyForContainer } from "../Utils/Telemetry/TelemetryEntity";
 import { getEntityBudget } from "../Utils/Telemetry/EntityRegistry";
 import { EntityScopeQueryValue } from "../Utils/AnalyticsDatabase/StatementGenerator";
+import Includes from "../../Types/BaseDatabase/Includes";
+import EqualTo from "../../Types/BaseDatabase/EqualTo";
 import InventoryItemService from "./InventoryItemService";
 import InventoryItem from "../../Models/DatabaseModels/InventoryItem";
 import EntityType from "../../Types/Telemetry/EntityType";
@@ -1030,6 +1032,12 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
         }
       }
 
+      /*
+       * No rollup can serve this aggregation, so it reads the raw table.
+       * Narrow that scan to the queried entity before it is compiled.
+       */
+      this.applyRawEntityKeyPrune(aggregateBy);
+
       if (
         aggregateBy.aggregateColumnName.toString() === "value" &&
         aggregateBy.aggregationTimestampColumnName.toString() === "time"
@@ -1043,6 +1051,13 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       return super.toAggregateStatement(aggregateBy);
     }
 
+    /*
+     * Percentiles never route to a rollup (the MVs store sum/count/min/max
+     * states, not quantile states), so every percentile aggregation reads
+     * the raw table and wants the same entity prune.
+     */
+    this.applyRawEntityKeyPrune(aggregateBy);
+
     const percentileLevel: number | null = getPercentileLevel(
       aggregateBy.aggregationType,
     );
@@ -2569,6 +2584,185 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     return { route, keys: [expectedKey] };
   }
 
+  /**
+   * Entity keys derivable from ONE attribute filter on a recognized
+   * entity attribute, or null when this filter shape yields no provable
+   * key set.
+   *
+   * Accepts the shapes an entity filter actually arrives in — a bare
+   * string, `EqualTo(string)`, and `Includes([...strings])` ("is any
+   * of") — because for each of those the set of matching rows is exactly
+   * the union of the listed values' entities. Everything else (negations
+   * like NotEqual / IncludesNone, substring operators, numbers, arrays of
+   * AND-ed operators) is refused: their matching set is not a finite
+   * enumerable key set, so no key predicate could be proven lossless.
+   */
+  private getEntityKeysForAttributeFilter(data: {
+    route: EntityMVRoute;
+    projectId: string;
+    attributeValue: unknown;
+  }): Array<string> | null {
+    const keyForValue: ((projectId: string, value: string) => string) | null =
+      data.route.keyForValue;
+
+    /*
+     * Service is excluded for the same reason it is excluded from the
+     * single-attribute MV route: ingest folds `service.namespace` into
+     * the key, so a bare name does not derive the stamped key and the
+     * predicate could drop the namespaced variants' rows.
+     */
+    if (!keyForValue) {
+      return null;
+    }
+
+    const rawValues: Array<unknown> =
+      data.attributeValue instanceof Includes
+        ? (data.attributeValue.values as Array<unknown>) || []
+        : [
+            data.attributeValue instanceof EqualTo
+              ? (data.attributeValue.value as unknown)
+              : data.attributeValue,
+          ];
+
+    const keys: Array<string> = [];
+    for (const rawValue of rawValues) {
+      /*
+       * One non-string (or empty) member makes the whole union
+       * underivable — refuse rather than prune to a partial set, which
+       * would silently drop rows.
+       */
+      if (typeof rawValue !== "string" || !rawValue) {
+        return null;
+      }
+      const key: string = keyForValue(data.projectId, rawValue);
+      if (!keys.includes(key)) {
+        keys.push(key);
+      }
+    }
+
+    return keys.length > 0 ? keys : null;
+  }
+
+  /**
+   * Narrow a raw-table aggregation to the entity it filters on, by
+   * ANDing a predicate on the bloom-indexed scalar entity-key column
+   * onto the query.
+   *
+   * WHY: `attributes` is a Map column with no index and no place in the
+   * sort key, so `attributes['resource.host.name'] = 'web-1'` cannot
+   * prune a single granule — ClickHouse reads EVERY row for the
+   * project+metric in the window and evaluates the map lookup per row.
+   * The per-entity rollups (tryBuildEntityAggregateMVStatement) hide
+   * that for the common single-filter case, but they decline as soon as
+   * the query carries anything they cannot express: a second attribute
+   * filter (`state is any of system, user`), a group-by, a percentile, a
+   * distribution metric, a `Total` interval. Those queries then fall to
+   * the raw table UNPRUNED, and the scan cost grows with the window —
+   * measured on a production project, one host's `system.cpu.utilization`
+   * with a second attribute filter took ~1.5s over 1 hour but blew
+   * through the 45s `max_execution_time` over 1 week, returning either a
+   * 500 or (under `timeout_overflow_mode = 'break'`) a silently partial
+   * chart. With this prune the same 1-week query returns complete
+   * results in ~2.4s.
+   *
+   * WHY IT IS LOSSLESS: the added predicate can only ever remove rows the
+   * attribute predicate already removed. A row matching
+   * `attributes[<entity attr>] = v` either
+   *   - was ingested with the scalar key columns stamped, in which case
+   *     its `<keyColumn>` IS `keyFor<type>(projectId, v)` — the ingest
+   *     stamp and `keyForValue` are the same canonicalizing function
+   *     (see Common/Utils/Telemetry/EntityKey); or
+   *   - predates those columns, in which case it reads the non-Nullable
+   *     default `''`.
+   * Both are in the emitted `IN` set, so the predicate is a pure
+   * restriction on the scan, not on the result. (This is strictly safer
+   * than the rollup path it backstops, which drops the `''` rows.)
+   *
+   * Applied only after MV routing has declined — adding a key column to
+   * the query beforehand would fail the MVs' `mvQueryableColumns` gate
+   * and disable the fast path this backstops.
+   */
+  private applyRawEntityKeyPrune(aggregateBy: AggregateBy<Metric>): void {
+    const queryRecord: Record<string, unknown> =
+      (aggregateBy.query as unknown as Record<string, unknown>) || {};
+
+    /*
+     * Entity keys fold the tenant into the hash, so they are only
+     * derivable for a project-scoped query. Dashboard reads always are.
+     */
+    const projectIdValue: unknown = queryRecord["projectId"];
+    let projectId: string = "";
+    if (projectIdValue instanceof ObjectID) {
+      projectId = projectIdValue.toString();
+    } else if (typeof projectIdValue === "string") {
+      projectId = projectIdValue;
+    }
+    if (!projectId) {
+      return;
+    }
+
+    const attrs: unknown = queryRecord["attributes"];
+    if (!attrs || typeof attrs !== "object" || Array.isArray(attrs)) {
+      return;
+    }
+
+    const prunePredicates: Record<string, Includes> = {};
+
+    for (const [attrKey, attrValue] of Object.entries(
+      attrs as Record<string, unknown>,
+    )) {
+      const route: EntityMVRoute | undefined = ENTITY_MV_ROUTES.find(
+        (candidate: EntityMVRoute) => {
+          return candidate.attributeKey === attrKey;
+        },
+      );
+      if (!route) {
+        continue;
+      }
+
+      /*
+       * Never touch a key column the caller already constrained — theirs
+       * is the authoritative predicate, and a second one could only
+       * narrow it further.
+       */
+      if (queryRecord[route.keyColumn] !== undefined) {
+        continue;
+      }
+
+      // Models without the column (older schema) simply get no prune.
+      if (!this.model.getTableColumn(route.keyColumn)) {
+        continue;
+      }
+
+      const keys: Array<string> | null = this.getEntityKeysForAttributeFilter({
+        route,
+        projectId,
+        attributeValue: attrValue,
+      });
+      if (!keys) {
+        continue;
+      }
+
+      // '' keeps rows ingested before the key columns existed. See above.
+      prunePredicates[route.keyColumn] = new Includes([...keys, ""]);
+    }
+
+    if (Object.keys(prunePredicates).length === 0) {
+      return;
+    }
+
+    /*
+     * Replace `query` rather than mutating it in place: callers (the API
+     * aggregate cache, the metric-monitor worker) may still hold the
+     * object they passed in. `aggregateBy` itself keeps its identity, so
+     * the point-type / service-key hints keyed on it in WeakMaps survive.
+     */
+    aggregateBy.query = {
+      ...(aggregateBy.query as unknown as Record<string, unknown>),
+      ...prunePredicates,
+    } as unknown as typeof aggregateBy.query;
+  }
+
   private stripEntityFilterAndTimeFromQuery(query: unknown): typeof query {
     if (!query || typeof query !== "object") {
       return query;

package/Server/Services/MonitorService.ts

@@ -10,6 +10,8 @@ import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import DatabaseService from "./DatabaseService";
+import CustomFieldMappingService from "./CustomFieldMappingService";
+import CustomFieldMappingSourceResource from "../../Types/CustomField/CustomFieldMappingSourceResource";
 import MonitorLabelRuleEngineService from "./MonitorLabelRuleEngineService";
 import MonitorOwnerRuleEngineService from "./MonitorOwnerRuleEngineService";
 import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
@@ -19,6 +21,8 @@ import MonitorStatusService from "./MonitorStatusService";
 import ServiceLevelObjectiveMonitorRuleEngineService from "./ServiceLevelObjectiveMonitorRuleEngineService";
 import StatusPageMonitorRuleEngineService from "./StatusPageMonitorRuleEngineService";
 import NetworkSiteService from "./NetworkSiteService";
+import NetworkDeviceService from "./NetworkDeviceService";
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
 import MonitorStatusTimelineService, {
   MONITOR_STATUS_SAME_AS_PREVIOUS_ERROR_MESSAGE,
   MONITOR_STATUS_TIMELINE_LOCK_ERROR_MESSAGE,
@@ -237,6 +241,21 @@ export class Service extends DatabaseService<Model> {
             monitorDestination = `${sql.host}:${sql.port}/${sql.databaseName}`;
           }
         }
+
+        // For Database Health monitors, show host:port/database (never the credentials).
+        if (
+          monitorType === MonitorType.Database &&
+          firstStep?.data?.databaseMonitor
+        ) {
+          const database: {
+            host: string;
+            port: number;
+            databaseName: string;
+          } = firstStep.data.databaseMonitor;
+          if (database.host) {
+            monitorDestination = `${database.host}:${database.port}/${database.databaseName}`;
+          }
+        }
       }
     }
 
@@ -296,6 +315,7 @@ export class Service extends DatabaseService<Model> {
       id: monitorId,
       select: {
         _id: true,
+        projectId: true,
         currentMonitorStatusId: true,
       },
       props: {
@@ -313,6 +333,7 @@ export class Service extends DatabaseService<Model> {
         select: {
           _id: true,
           monitorStatusId: true,
+          projectId: true,
         },
         props: {
           isRoot: true,
@@ -343,6 +364,39 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      /*
+       * The update above is root (no tenantId), so onUpdateSuccess's
+       * tenant-gated changeMonitorStatus does not run for it and nothing
+       * else re-stamps the network devices bound to this monitor. Bridge
+       * them here, and only when the id actually moved - an unchanged
+       * status must not churn every site rollup above the device.
+       */
+      const projectId: ObjectID | undefined =
+        monitor.projectId || lastMonitorStatus.projectId;
+
+      if (!projectId) {
+        logger.warn(
+          `refreshMonitorCurrentStatus: monitor ${monitorId.toString()} has no projectId; skipping the network site rollup bridge.`,
+        );
+        return;
+      }
+
+      try {
+        await NetworkSiteService.onMonitorStatusChanged({
+          projectId: projectId,
+          monitorIds: [monitorId],
+          monitorStatusId: lastMonitorStatus.monitorStatusId,
+        });
+      } catch (err) {
+        logger.error(
+          `refreshMonitorCurrentStatus: failed to update network site rollups for monitor ${monitorId.toString()}: ${err}`,
+          {
+            projectId: projectId.toString(),
+            monitorId: monitorId.toString(),
+          } as LogAttributes,
+        );
+      }
     }
   }
 
@@ -408,10 +462,65 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    /*
+     * Network devices bound to these monitors (NetworkDevice.monitorId, the
+     * monitor-backed path). The FK is ON DELETE SET NULL, so the binding
+     * disappears with the monitor - but the device's stamped
+     * currentMonitorStatusId / isReachable do not, and nothing else ever
+     * clears them: the device would keep reporting the dead monitor's last
+     * status forever. The ids have to be read BEFORE the delete, because
+     * after it the column that links them is already NULL.
+     *
+     * A lookup failure degrades to "no re-stamp" rather than blocking the
+     * delete itself: a device carrying a stale stamp is a cosmetic bug, a
+     * monitor the operator cannot delete is not.
+     */
+    let networkDeviceIdsToRefresh: Array<ObjectID> = [];
+
+    const monitorIdsPendingDeletion: Array<ObjectID> = monitorsPendingDeletion
+      .map((monitor: Model) => {
+        return monitor.id;
+      })
+      .filter((id: ObjectID | null): id is ObjectID => {
+        return Boolean(id);
+      });
+
+    if (monitorIdsPendingDeletion.length > 0) {
+      try {
+        const boundDevices: Array<NetworkDevice> =
+          await NetworkDeviceService.findBy({
+            query: {
+              monitorId: QueryHelper.any(monitorIdsPendingDeletion),
+            },
+            select: {
+              _id: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        networkDeviceIdsToRefresh = boundDevices
+          .map((device: NetworkDevice) => {
+            return device.id;
+          })
+          .filter((id: ObjectID | null): id is ObjectID => {
+            return Boolean(id);
+          });
+      } catch (error) {
+        logger.error(
+          `Error while looking up network devices bound to monitors pending deletion: ${error}`,
+        );
+      }
+    }
+
     return {
       deleteBy,
       carryForward: {
         monitors: monitorsPendingDeletion,
+        networkDeviceIdsToRefresh: networkDeviceIdsToRefresh,
       },
     };
   }
@@ -434,6 +543,34 @@ export class Service extends DatabaseService<Model> {
      * A synchronous ALTER TABLE … DELETE on every monitor deletion is both
      * redundant and expensive.
      */
+
+    /*
+     * Re-derive the stamp of every device that was bound to a deleted
+     * monitor. The FK has nulled NetworkDevice.monitorId by now, so for a
+     * monitor-backed device this resolves to "nothing bound": stamp and
+     * isReachable both go to NULL (the device honestly reads Pending) and
+     * its site chain is recomputed. clearWhenNotMonitorBacked is false on
+     * purpose - an SNMP device's stamp comes from the Network Device monitor
+     * watching its walk, not from this column, and is not ours to clear.
+     * Per device and never propagating: one failed refresh must not stop the
+     * rest, nor fail a delete that has already happened.
+     */
+    const networkDeviceIdsToRefresh: Array<ObjectID> =
+      onDelete.carryForward?.networkDeviceIdsToRefresh || [];
+
+    for (const deviceId of networkDeviceIdsToRefresh) {
+      try {
+        await NetworkDeviceService.refreshStampedMonitorStatus({
+          deviceId: deviceId,
+          clearWhenNotMonitorBacked: false,
+        });
+      } catch (error) {
+        logger.error(
+          `Error while refreshing the stamped monitor status of network device ${deviceId.toString()} after its monitor was deleted: ${error}`,
+        );
+      }
+    }
+
     if (onDelete.deleteBy.props.tenantId && IsBillingEnabled) {
       try {
         await ActiveMonitoringMeteredPlan.reportQuantityToBillingProvider(
@@ -964,6 +1101,36 @@ export class Service extends DatabaseService<Model> {
           });
         }
 
+        /*
+         * The "stays in sync" half of custom field value mapping
+         * (OneUptime/oneuptime#3549): alerts, incidents and maintenance events
+         * attached to this monitor whose custom fields are configured to
+         * inherit from it are brought back in line.
+         *
+         * `!== undefined` rather than truthiness: clearing the bag arrives as
+         * `{}` or null, and is exactly the edit worth reacting to. In its own
+         * try/catch because a propagation failure must never fail the
+         * operator's save — the house rule for every side effect in this hook.
+         */
+        if (onUpdate.updateBy.data.customFields !== undefined) {
+          try {
+            await CustomFieldMappingService.propagateFromSourceRecord({
+              resource: CustomFieldMappingSourceResource.Monitor,
+              sourceId: monitorId,
+              projectId: projectId,
+            });
+          } catch (error) {
+            logger.error(
+              "Custom field value mapping: propagating monitor custom fields failed in MonitorService.onUpdateSuccess",
+              {
+                projectId: projectId?.toString(),
+                monitorId: monitorId?.toString(),
+              } as LogAttributes,
+            );
+            logger.error(error as Error);
+          }
+        }
+
         if (onUpdate.updateBy.data.monitorSteps) {
           const validMonitorStepIds: Array<string> = this.extractMonitorStepIds(
             onUpdate.updateBy.data.monitorSteps as MonitorSteps | JSONObject,
@@ -2578,6 +2745,14 @@ ${createdItem.description?.trim() || "No description provided."}
         statusTimeline.startsAt = startsAt;
       }
 
+      /*
+       * The network-site rollup bridge (stamping the NetworkDevices these
+       * monitors report on and refreshing their sites) is NOT called from
+       * here. It runs inside MonitorStatusTimelineService.onCreateSuccess,
+       * which this create reaches, so calling it here as well stamped every
+       * device twice - and that hook is the only place the PROBE path
+       * (which never comes through changeMonitorStatus) passes through.
+       */
       await this.createStatusTimelineWithRetry({
         statusTimeline: statusTimeline,
         props: props,
@@ -2585,27 +2760,6 @@ ${createdItem.description?.trim() || "No description provided."}
         monitorId: monitorId,
       });
     }
-
-    /*
-     * Bridge to the network-site rollup engine: stamp the NetworkDevices
-     * these monitors poll and refresh their sites' worst-of status.
-     * Resilient by contract - a rollup failure can never break a monitor
-     * status change (onMonitorStatusChanged also catches internally).
-     */
-    try {
-      await NetworkSiteService.onMonitorStatusChanged({
-        projectId: projectId,
-        monitorIds: monitorIds,
-        monitorStatusId: monitorStatusId,
-      });
-    } catch (err) {
-      logger.error(
-        `changeMonitorStatus: failed to update network site rollups: ${err}`,
-        {
-          projectId: projectId.toString(),
-        } as LogAttributes,
-      );
-    }
   }
 
   /*