@oneuptime/common 11.3.5 → 11.3.7

package/Server/Services/TeamMemberService.ts

@@ -28,6 +28,7 @@ import SubscriptionPlan, {
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import Email from "../../Types/Email";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import Name from "../../Types/Name";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
@@ -125,6 +126,15 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
     if (createBy.miscDataProps && createBy.miscDataProps["email"]) {
       const email: Email = new Email(createBy.miscDataProps["email"] as string);
 
+      /*
+       * Optional name supplied on the invite form. Used only to set the name on
+       * a brand-new user, or to backfill an existing user who has no name yet —
+       * we never overwrite a name the user has already set.
+       */
+      const nameValue: string | undefined = createBy.miscDataProps["name"]
+        ? (createBy.miscDataProps["name"] as string).trim()
+        : undefined;
+
       let user: User | null = await UserService.findByEmail(email, {
         isRoot: true,
       });
@@ -133,13 +143,40 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
 
       if (!user) {
         isNewUser = true;
+
         user = await UserService.createByEmail({
           email,
-          name: undefined, // name is not required for now.
+          name: nameValue ? new Name(nameValue) : undefined,
           props: {
             isRoot: true,
           },
         });
+      } else if (nameValue) {
+        /*
+         * User already exists. Backfill their name only if they don't have one
+         * yet; if they already have a name, leave it untouched.
+         */
+        const existingUser: User | null = await UserService.findOneById({
+          id: user.id!,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (existingUser && !existingUser.name?.toString()) {
+          await UserService.updateOneById({
+            id: user.id!,
+            data: {
+              name: new Name(nameValue),
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        }
       }
 
       createBy.data.userId = user.id!;

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -29,6 +29,7 @@ import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
 import ObjectID from "../../../Types/ObjectID";
 import IsNull from "../../../Types/BaseDatabase/IsNull";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
@@ -887,6 +888,36 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             continue;
           }
 
+          /*
+           * Multi-value exclusion (IncludesNone / "is none of"):
+           * `attributes['k'] NOT IN (...)`. Map subscript returns '' for a
+           * missing key, so (like NotEqual above) rows lacking the attribute
+           * pass the NOT IN test, which matches "the value is none of these".
+           * An empty IncludesNone is treated as "All" — skip the predicate
+           * rather than emit `NOT IN ()`. Values bind via a fresh `Includes`
+           * since Statement only types `Includes` as Array(String).
+           */
+          if (mapEntry instanceof IncludesNone) {
+            const excludeValues: Array<string> = (
+              (mapEntry as IncludesNone).values || []
+            ).map((v: string | ObjectID | number) => {
+              return String(v);
+            });
+            if (excludeValues.length === 0) {
+              continue;
+            }
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] NOT IN ${{
+                value: new Includes(excludeValues),
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
           // Bare string/number/boolean — direct Map subscript.
           whereStatement.append(
             SQL`AND ${key}[${{

package/Server/Utils/Monitor/IncomingRequestIncidentGrouping.ts

@@ -0,0 +1,428 @@
+import logger from "../Logger";
+import VMUtil from "../VM/VMAPI";
+import MetricSeriesFingerprint from "../../../Utils/Metrics/MetricSeriesFingerprint";
+import DataToProcess from "./DataToProcess";
+import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
+import IncidentGroupingConfig from "../../../Types/Monitor/IncomingMonitor/IncidentGroupingConfig";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import { PerSeriesCriteriaMatch } from "../../../Types/Probe/ProbeApiIngestResponse";
+import { JSONObject, JSONValue } from "../../../Types/JSON";
+import Typeof from "../../../Types/Typeof";
+
+/**
+ * One key extracted from an incoming webhook payload by an
+ * {@link IncidentGroupingConfig}.
+ */
+export interface IncomingRequestGroupingItem {
+  /** Stable dedupe key derived from the extracted value. */
+  fingerprint: string;
+  /** Label map exposed to incident title/description templates. */
+  labels: JSONObject;
+  /** The raw extracted value (e.g. the Grafana alert name). */
+  keyValue: string;
+  /** True when the payload classifies this key as resolved/recovered. */
+  isResolved: boolean;
+}
+
+const DEFAULT_MAX_KEYS_PER_PAYLOAD: number = 100;
+const ARRAY_WILDCARD: string = "[*]";
+
+/**
+ * Turns an incoming-request / webhook payload into per-key incident
+ * matches, so a single monitor can hold multiple concurrent incidents —
+ * one per distinct value (Grafana alert name, fingerprint, etc.). This
+ * reuses the same `seriesFingerprint` mechanism metric monitors use for
+ * per-series incidents; see {@link IncidentGroupingConfig}.
+ */
+export default class IncomingRequestIncidentGrouping {
+  /**
+   * Parse the request body into a JSON object. Bodies arrive either
+   * pre-parsed (JSONObject) or as a raw JSON string depending on the
+   * ingestion path; both are handled. Non-JSON / non-object bodies
+   * (e.g. a bare string heartbeat) return null — grouping is a no-op.
+   */
+  public static getRequestBodyObject(
+    dataToProcess: DataToProcess,
+  ): JSONObject | null {
+    const body: string | JSONObject | undefined = (
+      dataToProcess as IncomingMonitorRequest
+    ).requestBody;
+
+    if (!body) {
+      return null;
+    }
+
+    if (typeof body === Typeof.String) {
+      try {
+        const parsed: unknown = JSON.parse(body as string);
+        return parsed &&
+          typeof parsed === Typeof.Object &&
+          !Array.isArray(parsed)
+          ? (parsed as JSONObject)
+          : null;
+      } catch {
+        return null;
+      }
+    }
+
+    if (typeof body === Typeof.Object && !Array.isArray(body)) {
+      return body as JSONObject;
+    }
+
+    return null;
+  }
+
+  /**
+   * Firing matches for one criteria — used by the criteria evaluator to
+   * fan a matched incoming-request criteria into one incident per key.
+   * Returns an empty array when grouping is not configured (preserving
+   * the legacy single-incident behaviour) or when there is no usable
+   * payload (e.g. the heartbeat-timeout re-evaluation cron, which carries
+   * no fresh body).
+   */
+  public static collectFiringMatches(input: {
+    dataToProcess: DataToProcess;
+    criteriaInstance: MonitorCriteriaInstance;
+    rootCause?: string | undefined;
+  }): Array<PerSeriesCriteriaMatch> {
+    const grouping: IncidentGroupingConfig | undefined =
+      input.criteriaInstance.data?.incidentGrouping;
+
+    if (!grouping?.groupByJSONPath) {
+      return [];
+    }
+
+    if (
+      (input.dataToProcess as IncomingMonitorRequest)
+        .onlyCheckForIncomingRequestReceivedAt
+    ) {
+      return [];
+    }
+
+    const criteriaId: string | undefined = input.criteriaInstance.data?.id;
+    if (!criteriaId) {
+      return [];
+    }
+
+    const body: JSONObject | null = this.getRequestBodyObject(
+      input.dataToProcess,
+    );
+    if (!body) {
+      return [];
+    }
+
+    const matches: Array<PerSeriesCriteriaMatch> = [];
+
+    for (const item of this.extractItems({ requestBody: body, grouping })) {
+      if (item.isResolved) {
+        // A resolved event never opens an incident.
+        continue;
+      }
+
+      matches.push({
+        criteriaMetId: criteriaId,
+        fingerprint: item.fingerprint,
+        labels: item.labels,
+        rootCause:
+          input.rootCause ||
+          `Incoming request matched grouping key \`${item.keyValue}\`.`,
+        metricContext: undefined,
+      });
+    }
+
+    return matches;
+  }
+
+  /**
+   * Fingerprints the payload explicitly classifies as resolved, across
+   * every grouping-enabled criteria on the monitor's step. The caller
+   * resolves the matching open incidents (event-driven resolution: only
+   * keys the payload says recovered are closed — never by absence).
+   */
+  public static collectResolvedFingerprints(input: {
+    dataToProcess: DataToProcess;
+    criteriaInstances: Array<MonitorCriteriaInstance>;
+  }): Array<string> {
+    if (
+      (input.dataToProcess as IncomingMonitorRequest)
+        .onlyCheckForIncomingRequestReceivedAt
+    ) {
+      return [];
+    }
+
+    const body: JSONObject | null = this.getRequestBodyObject(
+      input.dataToProcess,
+    );
+    if (!body) {
+      return [];
+    }
+
+    const fingerprints: Set<string> = new Set<string>();
+
+    for (const criteriaInstance of input.criteriaInstances) {
+      const grouping: IncidentGroupingConfig | undefined =
+        criteriaInstance.data?.incidentGrouping;
+
+      if (!grouping?.groupByJSONPath) {
+        continue;
+      }
+
+      for (const item of this.extractItems({ requestBody: body, grouping })) {
+        if (item.isResolved) {
+          fingerprints.add(item.fingerprint);
+        }
+      }
+    }
+
+    return Array.from(fingerprints);
+  }
+
+  /**
+   * Whether any criteria on the step has grouping configured. Used to
+   * force per-series mode so a grouped criteria never falls back to a
+   * single whole-monitor incident on a payload that yields no firing key.
+   */
+  public static isGroupingConfigured(
+    criteriaInstance: MonitorCriteriaInstance | undefined,
+  ): boolean {
+    return Boolean(criteriaInstance?.data?.incidentGrouping?.groupByJSONPath);
+  }
+
+  /**
+   * Extract all distinct keys from a payload for one grouping config,
+   * classifying each as firing or resolved. Deduplicates by fingerprint
+   * and caps the count at `maxKeysPerPayload` to bound cardinality.
+   */
+  public static extractItems(input: {
+    requestBody: JSONObject;
+    grouping: IncidentGroupingConfig;
+  }): Array<IncomingRequestGroupingItem> {
+    const { requestBody, grouping } = input;
+
+    const groupByPath: string = this.normalizePath(grouping.groupByJSONPath);
+    if (!groupByPath) {
+      return [];
+    }
+
+    const labelKey: string = this.labelKeyFromPath(groupByPath);
+    const maxKeys: number =
+      grouping.maxKeysPerPayload && grouping.maxKeysPerPayload > 0
+        ? grouping.maxKeysPerPayload
+        : DEFAULT_MAX_KEYS_PER_PAYLOAD;
+
+    const items: Array<IncomingRequestGroupingItem> = [];
+    const seenFingerprints: Set<string> = new Set<string>();
+
+    const addItem: (keyValue: string, isResolved: boolean) => void = (
+      keyValue: string,
+      isResolved: boolean,
+    ): void => {
+      const labels: JSONObject = { [labelKey]: keyValue };
+      const fingerprint: string =
+        MetricSeriesFingerprint.computeFingerprint(labels);
+
+      if (seenFingerprints.has(fingerprint)) {
+        // Same key twice in one payload — keep the first occurrence.
+        return;
+      }
+
+      seenFingerprints.add(fingerprint);
+      items.push({ fingerprint, labels, keyValue, isResolved });
+    };
+
+    const wildcardIndex: number = groupByPath.indexOf(ARRAY_WILDCARD);
+
+    // Simple (non-array) path: a single key for the whole payload.
+    if (wildcardIndex === -1) {
+      const keyValue: string | null = this.toScalarString(
+        VMUtil.deepFind(requestBody, groupByPath),
+      );
+
+      if (keyValue === null) {
+        return [];
+      }
+
+      addItem(
+        keyValue,
+        this.isResolvedForScope(requestBody, requestBody, grouping, false),
+      );
+      return items;
+    }
+
+    // Array fan-out: one key per element of the array at the `[*]` prefix.
+    const prefixPath: string = groupByPath
+      .slice(0, wildcardIndex)
+      .replace(/\.$/, "");
+    const elementSuffix: string = this.stripLeadingDot(
+      groupByPath.slice(wildcardIndex + ARRAY_WILDCARD.length),
+    );
+
+    const arrayValue: JSONValue | undefined = prefixPath
+      ? VMUtil.deepFind(requestBody, prefixPath)
+      : (requestBody as unknown as JSONValue);
+
+    if (!Array.isArray(arrayValue)) {
+      return [];
+    }
+
+    for (const element of arrayValue) {
+      if (items.length >= maxKeys) {
+        logger.warn(
+          `IncomingRequestIncidentGrouping: payload produced more than ${maxKeys} keys for path "${groupByPath}"; remaining keys ignored.`,
+        );
+        break;
+      }
+
+      const isObjectElement: boolean =
+        Boolean(element) && typeof element === Typeof.Object;
+
+      let keyValue: string | null;
+
+      if (elementSuffix) {
+        // `prefix[*].sub.path` — element must be an object to dig into.
+        if (!isObjectElement) {
+          continue;
+        }
+        keyValue = this.toScalarString(
+          VMUtil.deepFind(element as JSONObject, elementSuffix),
+        );
+      } else {
+        // `prefix[*]` — the array element itself is the key (array of scalars).
+        keyValue = this.toScalarString(element as JSONValue);
+      }
+
+      if (keyValue === null) {
+        continue;
+      }
+
+      /*
+       * Per-element resolve classification only applies when the element
+       * is an object (so `[*].status` can be read off it). For scalar
+       * elements there is no per-element field, so fall back to root scope.
+       */
+      addItem(
+        keyValue,
+        this.isResolvedForScope(
+          isObjectElement ? (element as JSONObject) : requestBody,
+          requestBody,
+          grouping,
+          isObjectElement,
+        ),
+      );
+    }
+
+    return items;
+  }
+
+  /**
+   * Classify whether the configured resolve condition holds. When the
+   * resolve path uses `[*]` AND we are evaluating a specific array element
+   * (`isElementContext`), it is read off that element (`elementScope`).
+   * Otherwise it is evaluated against the whole payload (`rootScope`).
+   *
+   * If the resolve path uses `[*]` but the group-by path does NOT (so we
+   * are not in element context — a self-contradictory config), the path is
+   * evaluated verbatim against the root: `deepFind` does not interpret
+   * `[*]`, so it returns undefined (not resolved) rather than silently
+   * rebinding to a same-named top-level field.
+   */
+  private static isResolvedForScope(
+    elementScope: JSONObject,
+    rootScope: JSONObject,
+    grouping: IncidentGroupingConfig,
+    isElementContext: boolean,
+  ): boolean {
+    if (
+      !grouping.resolvedWhenJSONPath ||
+      grouping.resolvedWhenValue === undefined
+    ) {
+      return false;
+    }
+
+    const resolvedPath: string = this.normalizePath(
+      grouping.resolvedWhenJSONPath,
+    );
+    const wildcardIndex: number = resolvedPath.indexOf(ARRAY_WILDCARD);
+
+    let scope: JSONObject = rootScope;
+    let path: string = resolvedPath;
+
+    if (wildcardIndex !== -1 && isElementContext) {
+      scope = elementScope;
+      path = this.stripLeadingDot(
+        resolvedPath.slice(wildcardIndex + ARRAY_WILDCARD.length),
+      );
+    }
+
+    if (!path) {
+      return false;
+    }
+
+    const value: string | null = this.toScalarString(
+      VMUtil.deepFind(scope, path),
+    );
+
+    return value !== null && value === grouping.resolvedWhenValue;
+  }
+
+  /**
+   * Derive a human-friendly label key from a JSON path — the last named
+   * segment, with array/wildcard syntax stripped. `alerts[*].labels.alertname`
+   * → `alertname`. Used as the template variable name (so titles can say
+   * `{{alertname}}`) and as the fingerprint label key.
+   */
+  private static labelKeyFromPath(path: string): string {
+    const cleaned: string = path
+      .replace(/\[\*\]/g, "")
+      .replace(/\[[^\]]*\]/g, "");
+    const parts: Array<string> = cleaned.split(".").filter(Boolean);
+    return parts.length > 0 ? parts[parts.length - 1]! : "key";
+  }
+
+  private static stripLeadingDot(path: string): string {
+    return path.startsWith(".") ? path.slice(1) : path;
+  }
+
+  /**
+   * Resolve the `requestBody`-rooted path users write — the same convention
+   * incident templates and JavaScript-expression filters use — into a path
+   * relative to the body (the actual scope `deepFind` resolves against).
+   * Both of these forms are accepted and resolve identically:
+   *
+   *   `{{requestBody.alerts[*].labels.alertname}}`   (template wrapper)
+   *   `requestBody.alerts[*].labels.alertname`
+   *
+   * The `requestBody` root is REQUIRED — a path not rooted there resolves
+   * to nothing, so the field has exactly one convention.
+   */
+  private static normalizePath(rawPath: string): string {
+    let path: string = rawPath.trim();
+
+    if (path.startsWith("{{") && path.endsWith("}}")) {
+      path = path.slice(2, -2).trim();
+    }
+
+    if (path.startsWith("requestBody.")) {
+      return path.slice("requestBody.".length);
+    }
+
+    return "";
+  }
+
+  /**
+   * Coerce an extracted value to a non-empty scalar string. Objects and
+   * arrays cannot be a grouping key and return null (the item is skipped).
+   */
+  private static toScalarString(value: JSONValue | undefined): string | null {
+    if (value === undefined || value === null) {
+      return null;
+    }
+
+    if (typeof value === Typeof.Object) {
+      return null;
+    }
+
+    const stringValue: string = String(value);
+    return stringValue.length > 0 ? stringValue : null;
+  }
+}