@oneuptime/common 12.0.19 → 12.0.21

package/Utils/EnterpriseLicense/EnterpriseLicenseSync.ts

@@ -0,0 +1,244 @@
+import GlobalConfig from "../../Models/DatabaseModels/GlobalConfig";
+import PartialEntity from "../../Types/Database/PartialEntity";
+import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
+import { JSONObject } from "../../Types/JSON";
+
+export interface EnterpriseLicenseSyncResult {
+  /*
+   * Only the columns the license server actually spoke about. A column the
+   * response did not mention is absent from this object, so updateOneById
+   * leaves whatever is stored alone.
+   */
+  updateData: PartialEntity<GlobalConfig>;
+
+  /*
+   * Fields the server sent in a shape this build cannot use. Returned rather
+   * than logged so this stays a pure function the tests can drive directly;
+   * the caller decides how loud to be about them.
+   */
+  warnings: Array<string>;
+}
+
+/*
+ * Maps a license-server response (from /enterprise-license/validate or
+ * /enterprise-license/report-user-count) onto the GlobalConfig columns a
+ * self-hosted installation mirrors locally.
+ *
+ * Every field is three-state, and the distinction is the whole contract:
+ *
+ *   key absent  - the license server did not speak about this field. That is
+ *                 what an oneuptime.com older than this build looks like, so
+ *                 the stored value is left exactly as it is. Collapsing this
+ *                 to null is how a daily report would wipe a perfectly good
+ *                 license expiry and take the installation down.
+ *   null        - the server explicitly says "there is no value". Written as
+ *                 null, so clearing a seat limit on oneuptime.com actually
+ *                 clears it on the customer's installation.
+ *   a value     - validated, then written.
+ *
+ * Anything that is neither absent, null, nor a usable value is treated as
+ * absent and reported as a warning: a malformed response must never be able
+ * to corrupt license state that was correct a moment ago.
+ */
+export default class EnterpriseLicenseSyncUtil {
+  /*
+   * The license key is deliberately NOT synced. The installation authenticates
+   * with the key it already holds, and a response must never be able to swap
+   * it for another one.
+   */
+  public static getGlobalConfigUpdateFromLicenseResponse(data: {
+    payload: JSONObject;
+    /*
+     * Used as the "user count as of" stamp when the server reports a count but
+     * no timestamp for it. Passed in rather than read from the clock so the
+     * function stays pure.
+     */
+    reportedAt: Date;
+  }): EnterpriseLicenseSyncResult {
+    const payload: JSONObject = data.payload || {};
+    const updateData: PartialEntity<GlobalConfig> = {};
+    const warnings: Array<string> = [];
+
+    /*
+     * The seat limit. This is the field customers change on oneuptime.com and
+     * then wait for: without it here, buying seats never reaches the
+     * installation that is enforcing the old number.
+     */
+    if (this.isPresent(payload, "userLimit")) {
+      const rawUserLimit: unknown = payload["userLimit"];
+
+      if (rawUserLimit === null) {
+        updateData.enterpriseLicenseUserLimit = null;
+      } else if (this.isNonNegativeInteger(rawUserLimit)) {
+        updateData.enterpriseLicenseUserLimit = rawUserLimit as number;
+      } else {
+        warnings.push(
+          `Ignored userLimit "${String(
+            rawUserLimit,
+          )}" from the license server: it is not a non-negative whole number.`,
+        );
+      }
+    }
+
+    /*
+     * The count and its timestamp move together: a count with a stamp from a
+     * previous report would read as "confirmed today", which is the exact
+     * lie this whole sync exists to stop telling.
+     */
+    if (this.isPresent(payload, "currentUserCount")) {
+      const rawUserCount: unknown = payload["currentUserCount"];
+
+      if (this.isNonNegativeInteger(rawUserCount)) {
+        updateData.enterpriseLicenseCurrentUserCount = rawUserCount as number;
+        updateData.enterpriseLicenseUserCountUpdatedAt =
+          this.parseDate(payload["userCountUpdatedAt"]) || data.reportedAt;
+      } else if (rawUserCount === null) {
+        /*
+         * The server has never had a count for this license. Nothing useful to
+         * store, and blanking the last known count would be worse than keeping
+         * it, so leave both columns alone.
+         */
+        warnings.push(
+          "The license server reported no user count for this license. Keeping the previously stored usage.",
+        );
+      } else {
+        warnings.push(
+          `Ignored currentUserCount "${String(
+            rawUserCount,
+          )}" from the license server: it is not a non-negative whole number. Keeping the previously stored usage.`,
+        );
+      }
+    }
+
+    /*
+     * Expiry drives licenseValid on the installation, so a renewal that never
+     * arrives here shows up as a license that expires on its original date
+     * however much the customer paid. Null is treated as absent on purpose: a
+     * report is not the place to strip an installation of its expiry.
+     */
+    if (this.isPresent(payload, "expiresAt") && payload["expiresAt"] !== null) {
+      const expiresAt: Date | null = this.parseDate(payload["expiresAt"]);
+
+      if (expiresAt) {
+        updateData.enterpriseLicenseExpiresAt = expiresAt;
+      } else {
+        warnings.push(
+          `Ignored expiresAt "${String(
+            payload["expiresAt"],
+          )}" from the license server: it is not a date.`,
+        );
+      }
+    }
+
+    if (this.isPresent(payload, "isEvaluationLicense")) {
+      const rawIsEvaluation: unknown = payload["isEvaluationLicense"];
+
+      if (typeof rawIsEvaluation === "boolean") {
+        updateData.enterpriseLicenseIsEvaluation = rawIsEvaluation;
+      } else {
+        warnings.push(
+          `Ignored isEvaluationLicense "${String(
+            rawIsEvaluation,
+          )}" from the license server: it is not a boolean.`,
+        );
+      }
+    }
+
+    if (this.isPresent(payload, "companyName")) {
+      const companyName: string = this.parseNonEmptyString(
+        payload["companyName"],
+      );
+
+      /*
+       * An empty company name is what the server sends for a license with none
+       * set, and overwriting a good name with "" would be a visible regression
+       * in the modal. Only a real name is worth writing.
+       */
+      if (companyName) {
+        updateData.enterpriseCompanyName = companyName;
+      }
+    }
+
+    /*
+     * The token is opaque here - it is signed with the license server's secret
+     * and this side only checks that it exists. It is never cleared: a license
+     * that has expired is legitimately issued no token, and clearing it on the
+     * way past would compound an expiry the customer may be about to renew.
+     */
+    if (this.isPresent(payload, "token")) {
+      const token: string = this.parseNonEmptyString(payload["token"]);
+
+      if (token) {
+        updateData.enterpriseLicenseToken = token;
+      }
+    }
+
+    if (this.isPresent(payload, "instances")) {
+      const rawInstances: unknown = payload["instances"];
+
+      if (Array.isArray(rawInstances)) {
+        updateData.enterpriseLicenseInstances =
+          rawInstances as Array<EnterpriseLicenseInstanceSummary>;
+      } else {
+        warnings.push(
+          "Ignored the instance list from the license server: it is not an array.",
+        );
+      }
+    }
+
+    return {
+      updateData: updateData,
+      warnings: warnings,
+    };
+  }
+
+  /*
+   * Present means the key is on the object, even when it carries null or
+   * undefined. `"x" in payload` rather than a truthiness or undefined check,
+   * because "the server said null" and "the server said nothing" have to stay
+   * distinguishable all the way down.
+   */
+  private static isPresent(payload: JSONObject, key: string): boolean {
+    if (!Object.prototype.hasOwnProperty.call(payload, key)) {
+      return false;
+    }
+
+    // An explicit undefined is indistinguishable from silence. Treat it as one.
+    return payload[key] !== undefined;
+  }
+
+  private static isNonNegativeInteger(value: unknown): boolean {
+    return (
+      typeof value === "number" &&
+      Number.isFinite(value) &&
+      Number.isInteger(value) &&
+      value >= 0
+    );
+  }
+
+  private static parseNonEmptyString(value: unknown): string {
+    if (typeof value !== "string") {
+      return "";
+    }
+
+    return value.trim();
+  }
+
+  private static parseDate(value: unknown): Date | null {
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? null : value;
+    }
+
+    if (typeof value !== "string" || !value.trim()) {
+      return null;
+    }
+
+    const parsed: Date = new Date(value.trim());
+
+    if (Number.isNaN(parsed.getTime())) {
+      return null;
+    }
+
+    return parsed;
+  }
+}

package/Utils/Metrics/MetricExplorerUrl.ts

@@ -1,4 +1,5 @@
 import Dictionary from "../../Types/Dictionary";
+import Includes from "../../Types/BaseDatabase/Includes";
 import JSONFunctions from "../../Types/JSONFunctions";
 import OneUptimeDate from "../../Types/Date";
 import MetricFormulaConfigData from "../../Types/Metrics/MetricFormulaConfigData";
@@ -32,6 +33,15 @@ export enum MetricExplorerUrlParam {
    * (which never had a range param) keep working as pinned windows.
    */
   Range = "range",
+  /*
+   * One-shot service scope: a JSON array of Service ObjectID strings,
+   * emitted by cross-signal pivots (logs/traces -> metrics). The explorer
+   * resolves the ids to service names on load, folds them into every
+   * query's `resource.service.name` attribute filter (the metric store's
+   * service dimension), and then DELETES the param on its next write-back
+   * — the scope lives on as ordinary, user-editable attribute filters.
+   */
+  Services = "services",
 }
 
 export interface SerializedMetricQueryAlias {
@@ -60,7 +70,7 @@ export interface SerializedMetricQuery {
    * lettering (a, b, ...).
    */
   variable?: string | undefined;
-  attributes?: Dictionary<string | number | boolean> | undefined;
+  attributes?: Dictionary<SerializedMetricAttributeValue> | undefined;
   aggregationType?: MetricsAggregationType | undefined;
   alias?: SerializedMetricQueryAlias | undefined;
   groupByAttributeKeys?: Array<string> | undefined;
@@ -90,7 +100,59 @@ export interface SerializedMetricFormula {
   criticalThreshold?: number | undefined;
 }
 
+/*
+ * One attribute filter value inside the serialized `metricQueries` param.
+ * Scalars are equality filters; Includes is the "any of" membership the
+ * UI's operator layer and the query layer both understand. It JSON-
+ * serializes to {_type: "Includes", value: [...]} (its toJSON), which the
+ * parse side rebuilds into a real instance — that round trip is how a
+ * multi-service scope survives Copy Link and saved views.
+ */
+export type SerializedMetricAttributeValue =
+  | string
+  | number
+  | boolean
+  | Includes;
+
+const MAX_SERVICES_PARAM_ENTRIES: number = 20;
+
 export default class MetricExplorerUrl {
+  /**
+   * Parses the `services` param: a JSON array of non-empty strings,
+   * deduped, capped. Garbage yields [] — same defensive posture as the
+   * other param parsers.
+   */
+  public static parseServicesParam(raw: string): Array<string> {
+    let parsedValue: unknown = null;
+
+    try {
+      parsedValue = JSONFunctions.parse(raw);
+    } catch {
+      return [];
+    }
+
+    if (!Array.isArray(parsedValue)) {
+      return [];
+    }
+
+    const serviceIds: Array<string> = [];
+
+    for (const entry of parsedValue) {
+      if (
+        typeof entry === "string" &&
+        entry.trim() !== "" &&
+        !serviceIds.includes(entry)
+      ) {
+        serviceIds.push(entry);
+      }
+      if (serviceIds.length >= MAX_SERVICES_PARAM_ENTRIES) {
+        break;
+      }
+    }
+
+    return serviceIds;
+  }
+
   /*
    * Builds the full URL param dictionary for a metric-view state. Keys
    * are only present when they carry a value (empty/meaningless queries
@@ -188,7 +250,7 @@ export default class MetricExplorerUrl {
     const metricName: string =
       typeof metricNameValue === "string" ? metricNameValue : "";
 
-    const attributes: Dictionary<string | number | boolean> =
+    const attributes: Dictionary<SerializedMetricAttributeValue> =
       MetricExplorerUrl.sanitizeAttributes(filterDataRecord["attributes"]);
 
     const aggregationType: MetricsAggregationType | undefined =
@@ -336,7 +398,7 @@ export default class MetricExplorerUrl {
           ? (entryRecord["variable"] as string)
           : undefined;
 
-      const attributes: Dictionary<string | number | boolean> =
+      const attributes: Dictionary<SerializedMetricAttributeValue> =
         MetricExplorerUrl.sanitizeAttributes(entryRecord["attributes"]);
 
       const aggregationType: MetricsAggregationType | undefined =
@@ -552,7 +614,7 @@ export default class MetricExplorerUrl {
 
   public static sanitizeAttributes(
     value: unknown,
-  ): Dictionary<string | number | boolean> {
+  ): Dictionary<SerializedMetricAttributeValue> {
     if (value === null || value === undefined) {
       return {};
     }
@@ -575,7 +637,7 @@ export default class MetricExplorerUrl {
       return {};
     }
 
-    const attributes: Dictionary<string | number | boolean> = {};
+    const attributes: Dictionary<SerializedMetricAttributeValue> = {};
 
     for (const key in candidate as Record<string, unknown>) {
       const attributeValue: unknown = (candidate as Record<string, unknown>)[
@@ -588,12 +650,64 @@ export default class MetricExplorerUrl {
         typeof attributeValue === "boolean"
       ) {
         attributes[key] = attributeValue;
+        continue;
+      }
+
+      /*
+       * "Any of" membership filters. Live view state holds Includes
+       * INSTANCES; parsed URLs hold the plain {_type, value} JSON shape.
+       * Both normalize to a fresh instance so multi-value filters (e.g.
+       * a multi-service scope) survive Copy Link / saved views instead
+       * of being silently dropped — and downstream consumers (the query
+       * layer, the operator detector, the monitor evaluator's deep-link
+       * builder) all already speak Includes.
+       */
+      const membershipValues: Array<string> | null =
+        MetricExplorerUrl.getIncludesShapeValues(attributeValue);
+
+      if (membershipValues !== null && membershipValues.length > 0) {
+        attributes[key] = new Includes(membershipValues);
       }
     }
 
     return attributes;
   }
 
+  private static getIncludesShapeValues(value: unknown): Array<string> | null {
+    let rawValues: unknown = null;
+
+    if (value instanceof Includes) {
+      rawValues = value.values;
+    } else if (
+      value &&
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      (value as Record<string, unknown>)["_type"] === "Includes"
+    ) {
+      rawValues = (value as Record<string, unknown>)["value"];
+    } else {
+      return null;
+    }
+
+    if (!Array.isArray(rawValues)) {
+      return [];
+    }
+
+    const values: Array<string> = [];
+
+    for (const entry of rawValues) {
+      if (
+        (typeof entry === "string" && entry.trim() !== "") ||
+        typeof entry === "number" ||
+        typeof entry === "boolean"
+      ) {
+        values.push(String(entry));
+      }
+    }
+
+    return values;
+  }
+
   private static buildAliasFromMetricAliasData(
     data: MetricQueryConfigData["metricAliasData"],
   ): SerializedMetricQueryAlias | undefined {

package/Utils/Telemetry/CrossSignalScope.ts

@@ -51,7 +51,9 @@ const WHITESPACE: RegExp = /\s/;
  *  - Metric explorer (Common/Utils/Metrics/MetricExplorerUrl.ts): the
  *    JSON-encoded `metricQueries` param plus absolute `startTime`/`endTime`
  *    (a pinned Custom window is represented by the absolute params alone —
- *    no `range` token).
+ *    no `range` token), plus the one-shot `services` param (JSON array of
+ *    Service ObjectID strings) that the explorer resolves to
+ *    `resource.service.name` attribute filters on load.
  */
 
 /**
@@ -535,11 +537,11 @@ export function toTracesExplorerQueryParams(
  * Custom by the absolute params alone — see MetricExplorerUrl). The
  * optional `metricName` argument names the query.
  *
- * Dropped: serviceIds, resourceFacetSelections, traceIds, spanIds,
- * severityTexts, bodyContains — the metric explorer's URL grammar has no
- * service / resource / trace / span / severity / message dimension (metrics
- * carry a primaryEntityId column, but the explorer only parses metricName +
- * attributes out of `metricQueries`).
+ * Dropped: resourceFacetSelections, traceIds, spanIds, severityTexts,
+ * bodyContains — the metric explorer's URL grammar has no resource /
+ * trace / span / severity / message dimension. serviceIds DO carry, via
+ * the `services` param the explorer folds into `resource.service.name`
+ * attribute filters on load.
  */
 export function toMetricsExplorerQueryParams(
   scope: TelemetryCrossSignalScope,
@@ -567,6 +569,17 @@ export function toMetricsExplorerQueryParams(
     params[MetricExplorerUrlParam.MetricQueries] = JSON.stringify([query]);
   }
 
+  /*
+   * Service scope rides the one-shot `services` param — the explorer
+   * resolves ids to names and folds them into `resource.service.name`
+   * attribute filters on load, so serviceIds is no longer dropped.
+   */
+  const scopedServiceIds: Array<string> = sanitizeValues(scope.serviceIds);
+
+  if (scopedServiceIds.length > 0) {
+    params[MetricExplorerUrlParam.Services] = JSON.stringify(scopedServiceIds);
+  }
+
   const window: ResolvedTimeWindow = resolveTimeWindow(scope);
 
   if (window.startTime && window.endTime) {
@@ -578,10 +591,6 @@ export function toMetricsExplorerQueryParams(
     );
   }
 
-  if (sanitizeValues(scope.serviceIds).length > 0) {
-    dropped.push("serviceIds");
-  }
-
   for (const [facetKey] of sanitizeResourceFacetSelections(
     scope.resourceFacetSelections,
   )) {