@oneuptime/common 12.0.33 → 13.0.0

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";
@@ -1099,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,

package/Server/Services/MonitorTemplateService.ts

@@ -22,6 +22,7 @@ import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "../../Models/DatabaseModels/MonitorTemplate";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import MonitorTemplateCustomFieldUtil from "../../Utils/Monitor/MonitorTemplateCustomFieldUtil";
 import NetworkDeviceMonitorTemplateUtil from "../../Utils/Monitor/NetworkDeviceMonitorTemplateUtil";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import ModelPermission from "../Types/Database/Permissions/Index";
@@ -41,9 +42,31 @@ export type SyncableTemplateField =
   | "monitorSteps"
   | "monitoringInterval"
   | "minimumProbeAgreement"
-  | "labels";
+  | "labels"
+  | "customFields";
 
-const ALL_SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
+const SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
+  "monitorSteps",
+  "monitoringInterval",
+  "minimumProbeAgreement",
+  "labels",
+  "customFields",
+];
+
+/*
+ * What an UNSCOPED sync pushes — every syncable field except custom field
+ * defaults.
+ *
+ * Custom fields are the one syncable thing whose per-monitor value is
+ * ordinarily typed in by hand: a monitor's Configuration Item or Vendor is
+ * about that device, not about the template. A caller that names no fields is
+ * saying "push the template", not "and also rewrite every operator-entered
+ * value in the fleet", so custom fields ship only when asked for by name —
+ * which is what the dedicated button on the template's Custom Field Defaults
+ * card does. The dashboard always scopes its syncs, so this only decides what
+ * an API caller gets by default.
+ */
+const DEFAULT_SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
   "monitorSteps",
   "monitoringInterval",
   "minimumProbeAgreement",
@@ -309,10 +332,10 @@ export class Service extends DatabaseService<Model> {
     fields: Array<string> | undefined,
   ): Array<SyncableTemplateField> {
     if (!fields || fields.length === 0) {
-      return [...ALL_SYNCABLE_FIELDS];
+      return [...DEFAULT_SYNCABLE_FIELDS];
     }
 
-    const allowed: Set<string> = new Set(ALL_SYNCABLE_FIELDS);
+    const allowed: Set<string> = new Set(SYNCABLE_FIELDS);
     for (const field of fields) {
       if (!allowed.has(field)) {
         throw new BadDataException(
@@ -323,6 +346,16 @@ export class Service extends DatabaseService<Model> {
     return fields as Array<SyncableTemplateField>;
   }
 
+  /*
+   * The part of the push that is identical for every linked monitor, so it can
+   * ride a single bulk update.
+   *
+   * `customFields` is deliberately absent: a template's custom fields are
+   * DEFAULTS overlaid on whatever the monitor already holds, which is a
+   * different value per monitor and therefore cannot be one shared payload.
+   * The two sync entry points below compute it per monitor instead — see
+   * buildCustomFieldsUpdate.
+   */
   private buildUpdateData(
     template: Model,
     fields: Array<SyncableTemplateField>,
@@ -330,6 +363,10 @@ export class Service extends DatabaseService<Model> {
     const updateData: Partial<Monitor> = {};
 
     for (const field of fields) {
+      if (field === "customFields") {
+        continue;
+      }
+
       const value: unknown = (template as unknown as Record<string, unknown>)[
         field
       ];
@@ -342,13 +379,46 @@ export class Service extends DatabaseService<Model> {
     return updateData;
   }
 
+  /*
+   * Does this push carry custom field defaults that are worth a write?
+   *
+   * A template whose bag is absent, empty, or holds nothing but blanks has no
+   * defaults to give, and saying so here is what stops a custom-fields-only
+   * sync from taking the per-monitor path (and reporting a fleet-wide write)
+   * to push nothing at all.
+   */
+  private hasCustomFieldDefaultsToSync(
+    template: Model,
+    fields: Array<SyncableTemplateField>,
+  ): boolean {
+    return (
+      fields.includes("customFields") &&
+      MonitorTemplateCustomFieldUtil.hasDefaults(template.customFields)
+    );
+  }
+
+  /*
+   * One monitor's custom field bag after the template's defaults are laid over
+   * it: the template wins every field it actually defaults, and every other
+   * value the operator entered on that monitor survives untouched.
+   */
+  private buildCustomFieldsUpdate(data: {
+    template: Model;
+    monitor: Monitor;
+  }): JSONObject {
+    return MonitorTemplateCustomFieldUtil.applyDefaults({
+      templateCustomFields: data.template.customFields,
+      monitorCustomFields: data.monitor.customFields,
+    });
+  }
+
   /**
    * Push the template's current configuration onto every monitor that was
    * created from it. Sync is intentionally explicit (button-triggered) so a
    * config tweak doesn't silently re-deploy across the whole fleet.
    *
    * Pass `fields` to scope the sync — e.g. `["monitorSteps"]` to push only the
-   * criteria. If omitted, every syncable field is pushed.
+   * criteria. If omitted, DEFAULT_SYNCABLE_FIELDS is pushed.
    */
   @CaptureSpan()
   public async syncLinkedMonitors(data: {
@@ -369,6 +439,7 @@ export class Service extends DatabaseService<Model> {
         monitorSteps: true,
         monitoringInterval: true,
         minimumProbeAgreement: true,
+        customFields: true,
         labels: {
           _id: true,
         },
@@ -398,7 +469,17 @@ export class Service extends DatabaseService<Model> {
 
     const updateData: Partial<Monitor> = this.buildUpdateData(template, fields);
 
-    if (Object.keys(updateData).length === 0) {
+    /*
+     * Custom field defaults never ride in updateData — the value written
+     * depends on what each monitor already holds — so they are their own
+     * reason for this push to have work to do.
+     */
+    const syncCustomFields: boolean = this.hasCustomFieldDefaultsToSync(
+      template,
+      fields,
+    );
+
+    if (Object.keys(updateData).length === 0 && !syncCustomFields) {
       return {
         totalLinkedMonitors,
         syncedMonitors: 0,
@@ -412,10 +493,16 @@ export class Service extends DatabaseService<Model> {
      * those rows individually and rebind cloned template steps to each
      * monitor's current (or provenance-backed) device instead.
      */
-    if (
+    const rebindMonitorSteps: boolean =
       template.monitorType === MonitorType.NetworkDevice &&
-      fields.includes("monitorSteps")
-    ) {
+      fields.includes("monitorSteps");
+
+    /*
+     * Custom field defaults take the same row-at-a-time path for their own
+     * reason: they are overlaid on the monitor's existing bag, so the payload
+     * is read from the row being written and cannot be shared.
+     */
+    if (rebindMonitorSteps || syncCustomFields) {
       let syncedMonitors: number = 0;
       const linkedMonitorQuery: Query<Monitor> = {
         monitorTemplateId: template.id!,
@@ -428,12 +515,20 @@ export class Service extends DatabaseService<Model> {
        * label scope order-dependent: accessible rows could update before a
        * later hidden row threw. This is the same permission-narrowed subset
        * the ordinary bulk update path applies atomically.
+       *
+       * The probe names `customFields` when this push writes them — the
+       * per-monitor values are not known yet, and only the KEYS decide the
+       * column check — so a caller who may not update that column is refused
+       * up front rather than on an arbitrary row partway through the fleet.
        */
       const authorizedMonitorQuery: Query<Monitor> =
         await ModelPermission.checkUpdateQueryPermissions(
           Monitor,
           linkedMonitorQuery,
-          updateData as any,
+          {
+            ...updateData,
+            ...(syncCustomFields ? { customFields: {} } : {}),
+          } as any,
           data.props,
         );
       const monitorsToSync: Array<Monitor> = [];
@@ -444,6 +539,7 @@ export class Service extends DatabaseService<Model> {
           select: {
             _id: true,
             monitorSteps: true,
+            customFields: true,
             autoProvisionedNetworkDeviceId: true,
           },
           sort: { createdAt: SortOrder.Ascending, _id: SortOrder.Ascending },
@@ -468,15 +564,27 @@ export class Service extends DatabaseService<Model> {
           monitor,
           data: {
             ...updateData,
-            monitorSteps: monitor.autoProvisionedNetworkDeviceId
-              ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
-                  monitorSteps: template.monitorSteps,
-                  networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
-                })
-              : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
-                  templateMonitorSteps: template.monitorSteps,
-                  currentMonitorSteps: monitor.monitorSteps,
-                }),
+            ...(rebindMonitorSteps
+              ? {
+                  monitorSteps: monitor.autoProvisionedNetworkDeviceId
+                    ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
+                        monitorSteps: template.monitorSteps,
+                        networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
+                      })
+                    : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
+                        templateMonitorSteps: template.monitorSteps,
+                        currentMonitorSteps: monitor.monitorSteps,
+                      }),
+                }
+              : {}),
+            ...(syncCustomFields
+              ? {
+                  customFields: this.buildCustomFieldsUpdate({
+                    template,
+                    monitor,
+                  }),
+                }
+              : {}),
           },
         };
       });
@@ -642,6 +750,7 @@ export class Service extends DatabaseService<Model> {
         monitorSteps: true,
         monitoringInterval: true,
         minimumProbeAgreement: true,
+        customFields: true,
         labels: {
           _id: true,
         },
@@ -664,6 +773,7 @@ export class Service extends DatabaseService<Model> {
         projectId: true,
         monitorTemplateId: true,
         monitorSteps: true,
+        customFields: true,
         autoProvisionedNetworkDeviceId: true,
       },
       props: { isRoot: true },
@@ -706,6 +816,17 @@ export class Service extends DatabaseService<Model> {
           });
     }
 
+    /*
+     * Overlaid on this monitor's own bag, so a value the operator entered on
+     * a field the template does not default survives the push.
+     */
+    if (this.hasCustomFieldDefaultsToSync(template, fields)) {
+      updateData.customFields = this.buildCustomFieldsUpdate({
+        template,
+        monitor,
+      });
+    }
+
     if (Object.keys(updateData).length === 0) {
       return;
     }