@oneuptime/common 12.0.19 → 12.0.20

package/UI/Components/Charts/ChartLibrary/AreaChart/AreaChart.tsx

@@ -39,6 +39,10 @@ import {
 import { cx } from "../Utils/Cx";
 import { getYAxisDomain } from "../Utils/GetYAxisDomain";
 import { hasOnlyOneValueForKey } from "../Utils/HasOnlyOneValueForKey";
+import {
+  PreparedTooltipEntries,
+  prepareTooltipEntries,
+} from "../Utils/TooltipEntries";
 import ChartCurve from "../../Types/ChartCurve";
 
 /*
@@ -475,9 +479,15 @@ const ChartTooltip: ({
   valueFormatter,
 }: ChartTooltipProps): React.JSX.Element | null => {
   if (active && payload && payload.length) {
-    const legendPayload: PayloadItem[] = payload.filter((item: PayloadItem) => {
-      return item.type !== "none";
-    });
+    /*
+     * Highest value at the hovered timestamp first, capped — on a grouped
+     * chart (one series per host/pod), the spiking series must be the
+     * first line of the tooltip, not buried at its alphabetical position.
+     */
+    const {
+      entries: legendPayload,
+      overflowCount,
+    }: PreparedTooltipEntries<PayloadItem> = prepareTooltipEntries(payload);
     return (
       <div
         className={cx(
@@ -531,6 +541,11 @@ const ChartTooltip: ({
               );
             },
           )}
+          {overflowCount > 0 ? (
+            <p className={cx("pt-1 text-xs", "text-gray-400")}>
+              +{overflowCount} more series — highest values shown
+            </p>
+          ) : null}
         </div>
       </div>
     );
@@ -1426,4 +1441,4 @@ const AreaChart: React.ForwardRefExoticComponent<
 
 AreaChart.displayName = "AreaChart";
 
-export { AreaChart, type AreaChartEventProps, type TooltipProps };
+export { AreaChart, ChartTooltip, type AreaChartEventProps, type TooltipProps };

package/UI/Components/Charts/ChartLibrary/BarChart/BarChart.tsx

@@ -33,6 +33,10 @@ import {
 } from "../Utils/ChartColors";
 import { cx } from "../Utils/Cx";
 import { getYAxisDomain } from "../Utils/GetYAxisDomain";
+import {
+  PreparedTooltipEntries,
+  prepareTooltipEntries,
+} from "../Utils/TooltipEntries";
 import { useOnWindowResize } from "../Utils/UseWindowOnResize";
 
 /*
@@ -562,6 +566,15 @@ const ChartTooltip: React.FunctionComponent<ChartTooltipProps> = ({
   valueFormatter,
 }: ChartTooltipProps): React.ReactElement | null => {
   if (active && payload && payload.length) {
+    /*
+     * Highest value at the hovered bucket first, capped — on a grouped
+     * chart (one series per host/pod), the spiking series must be the
+     * first line of the tooltip, not buried at its alphabetical position.
+     */
+    const {
+      entries: sortedPayload,
+      overflowCount,
+    }: PreparedTooltipEntries<PayloadItem> = prepareTooltipEntries(payload);
     return (
       <div
         className={cx(
@@ -586,7 +599,7 @@ const ChartTooltip: React.FunctionComponent<ChartTooltipProps> = ({
           </p>
         </div>
         <div className={cx("space-y-1 px-4 py-2")}>
-          {payload.map(
+          {sortedPayload.map(
             ({ value, category, color }: PayloadItem, index: number) => {
               return (
                 <div
@@ -631,6 +644,11 @@ const ChartTooltip: React.FunctionComponent<ChartTooltipProps> = ({
               );
             },
           )}
+          {overflowCount > 0 ? (
+            <p className={cx("pt-1 text-xs", "text-gray-400")}>
+              +{overflowCount} more series — highest values shown
+            </p>
+          ) : null}
         </div>
       </div>
     );
@@ -1194,4 +1212,4 @@ const BarChart: React.ForwardRefExoticComponent<
 
 BarChart.displayName = "BarChart";
 
-export { BarChart, type BarChartEventProps, type TooltipProps };
+export { BarChart, ChartTooltip, type BarChartEventProps, type TooltipProps };

package/UI/Components/Charts/ChartLibrary/LineChart/LineChart.tsx

@@ -40,6 +40,10 @@ import {
 import { cx } from "../Utils/Cx";
 import { getYAxisDomain } from "../Utils/GetYAxisDomain";
 import { hasOnlyOneValueForKey } from "../Utils/HasOnlyOneValueForKey";
+import {
+  PreparedTooltipEntries,
+  prepareTooltipEntries,
+} from "../Utils/TooltipEntries";
 import ChartCurve from "../../Types/ChartCurve";
 
 /*
@@ -478,9 +482,15 @@ const ChartTooltip: ({
   valueFormatter,
 }: ChartTooltipProps): React.JSX.Element | null => {
   if (active && payload && payload.length) {
-    const legendPayload: PayloadItem[] = payload.filter((item: PayloadItem) => {
-      return item.type !== "none";
-    });
+    /*
+     * Highest value at the hovered timestamp first, capped — on a grouped
+     * chart (one series per host/pod), the spiking series must be the
+     * first line of the tooltip, not buried at its alphabetical position.
+     */
+    const {
+      entries: legendPayload,
+      overflowCount,
+    }: PreparedTooltipEntries<PayloadItem> = prepareTooltipEntries(payload);
     return (
       <div
         className={cx(
@@ -550,6 +560,11 @@ const ChartTooltip: ({
               );
             },
           )}
+          {overflowCount > 0 ? (
+            <p className={cx("pt-1 text-xs", "text-gray-400")}>
+              +{overflowCount} more series — highest values shown
+            </p>
+          ) : null}
         </div>
       </div>
     );
@@ -1419,4 +1434,4 @@ const LineChart: React.ForwardRefExoticComponent<
 
 LineChart.displayName = "LineChart";
 
-export { LineChart, type LineChartEventProps, type TooltipProps };
+export { ChartTooltip, LineChart, type LineChartEventProps, type TooltipProps };

package/UI/Components/Charts/ChartLibrary/Utils/TooltipEntries.ts

@@ -0,0 +1,105 @@
+/*
+ * Shared ordering/capping for the hover tooltip of the Area / Line / Bar
+ * charts. With a grouped metric (say 20 hosts on one chart) the recharts
+ * payload arrives in series-render order — effectively alphabetical — so
+ * the series that is actually spiking at the hovered timestamp is buried
+ * mid-list. Sorting by the value AT THE HOVERED POINT puts the top series
+ * first, and capping the list keeps a high-cardinality chart's tooltip
+ * readable (the "+N more" line reports what was elided).
+ */
+
+/*
+ * The slice of a recharts tooltip payload item the ordering needs. The
+ * three chart implementations each declare their own structurally-equal
+ * PayloadItem, so this stays generic instead of importing any of them.
+ */
+export interface SortableTooltipItem {
+  category: string;
+  value: number;
+  type?: string | undefined;
+}
+
+export const DEFAULT_TOOLTIP_MAX_ENTRIES: number = 10;
+
+export interface PreparedTooltipEntries<T extends SortableTooltipItem> {
+  /** Entries to render, highest value first, capped at maxEntries. */
+  entries: Array<T>;
+  /** How many entries the cap hid (0 when everything fits). */
+  overflowCount: number;
+  /** Entry count after filtering, before capping. */
+  totalCount: number;
+}
+
+/*
+ * Natural compare so host names order like cpu0 < cpu2 < cpu10 instead of
+ * lexicographically — mirrors the series chips' name ordering.
+ */
+function compareCategoryNames(a: string, b: string): number {
+  return String(a).localeCompare(String(b), undefined, {
+    numeric: true,
+    sensitivity: "base",
+  });
+}
+
+export function prepareTooltipEntries<T extends SortableTooltipItem>(
+  payload: Array<T> | undefined | null,
+  maxEntries: number = DEFAULT_TOOLTIP_MAX_ENTRIES,
+): PreparedTooltipEntries<T> {
+  /*
+   * `type === "none"` entries are series excluded from legends/tooltips
+   * (recharts tooltipType) — every chart filtered them before this
+   * module existed, so the filter lives here now to stay uniform.
+   */
+  const visibleEntries: Array<T> = (payload || []).filter((item: T) => {
+    return item.type !== "none";
+  });
+
+  const sortedEntries: Array<T> = visibleEntries
+    .slice()
+    .sort((a: T, b: T): number => {
+      /*
+       * Non-finite values (missing points, the anomaly band's [low, high]
+       * array) sort last — they carry no "how high is this series right
+       * now" signal, so they must never displace a real reading.
+       */
+      const aValue: number | null =
+        typeof a.value === "number" && Number.isFinite(a.value)
+          ? a.value
+          : null;
+      const bValue: number | null =
+        typeof b.value === "number" && Number.isFinite(b.value)
+          ? b.value
+          : null;
+
+      if (aValue === null && bValue === null) {
+        return compareCategoryNames(a.category, b.category);
+      }
+      if (aValue === null) {
+        return 1;
+      }
+      if (bValue === null) {
+        return -1;
+      }
+      if (bValue !== aValue) {
+        return bValue - aValue;
+      }
+      return compareCategoryNames(a.category, b.category);
+    });
+
+  const totalCount: number = sortedEntries.length;
+
+  const cap: number =
+    Number.isInteger(maxEntries) && maxEntries > 0
+      ? maxEntries
+      : DEFAULT_TOOLTIP_MAX_ENTRIES;
+
+  if (totalCount <= cap) {
+    return { entries: sortedEntries, overflowCount: 0, totalCount };
+  }
+
+  return {
+    entries: sortedEntries.slice(0, cap),
+    overflowCount: totalCount - cap,
+    totalCount,
+  };
+}

package/UI/Components/Charts/Line/LineChart.tsx

@@ -161,7 +161,14 @@ const LineChartElement: FunctionComponent<LineInternalProps> = (
 
   return (
     <div
-      className="relative flex flex-1"
+      /*
+       * `isolate` opens a stacking context so the recharts tooltip's
+       * z-index competes only inside this chart — without it the tooltip
+       * (zIndex 10, pinned to the chart's top edge) ties with the app
+       * header's sticky z-10 in the root context and paints over the
+       * navbar on half-scrolled charts.
+       */
+      className="relative isolate flex flex-1"
       style={props.heightInPx ? { height: `${props.heightInPx}px` } : undefined}
     >
       <LineChart

package/UI/Components/Detail/Detail.tsx

@@ -715,7 +715,24 @@ const Detail: DetailFunction = <T extends GenericObject>(
     }
 
     if (field.getElement) {
-      data = field.getElement(props.item);
+      /*
+       * getField runs inside Detail's own render, so a throw out of a field
+       * renderer unwinds the whole route to the app level ErrorBoundary and
+       * replaces the page with "Something went wrong". One misbehaving field
+       * must never cost the entire page: log the misconfiguration and keep
+       * whatever this field type already rendered - the entity badge, or ""
+       * so the placeholder below can stand in.
+       */
+      try {
+        data = field.getElement(props.item);
+      } catch (err) {
+        Logger.error(
+          "Detail: getElement for '" +
+            fieldKeyStr +
+            "' threw and was ignored. " +
+            (err instanceof Error ? err.message : String(err)),
+        );
+      }
     }
 
     let className: string = "sm:col-span-1";

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/build/dist/Server/API/EnterpriseLicenseAPI.js

@@ -83,18 +83,13 @@ export default class EnterpriseLicenseAPI extends BaseAPI {
                     });
                 }
                 const instances = await this.findLicenseInstances(license.id);
-                const payload = {
-                    companyName: license.companyName || "",
-                    expiresAt: license.expiresAt.toISOString(),
-                    licenseKey: license.licenseKey || "",
-                    userLimit: typeof license.userLimit === "number" ? license.userLimit : null,
-                };
-                const token = JSONWebToken.signJsonPayload(payload, Math.max(secondsUntilExpiry, 1));
+                const terms = this.getLicenseTerms(license);
+                const token = this.signLicenseToken(license);
                 return Response.sendJsonObjectResponse(req, res, {
-                    companyName: payload["companyName"],
-                    expiresAt: payload["expiresAt"],
-                    licenseKey: payload["licenseKey"],
-                    userLimit: payload["userLimit"],
+                    companyName: terms.companyName,
+                    expiresAt: terms.expiresAt,
+                    licenseKey: terms.licenseKey,
+                    userLimit: terms.userLimit,
                     currentUserCount: typeof license.currentUserCount === "number"
                         ? license.currentUserCount
                         : null,
@@ -128,8 +123,19 @@ export default class EnterpriseLicenseAPI extends BaseAPI {
                     query: {
                         licenseKey: licenseKey,
                     },
+                    /*
+                     * The full set of terms, not just the usage columns: this
+                     * response is what a self-hosted installation mirrors into its
+                     * own GlobalConfig every day, so anything it is missing here is
+                     * a field the customer keeps the stale value of until somebody
+                     * re-types the license key by hand. Same indexed lookup either
+                     * way.
+                     */
                     select: {
                         _id: true,
+                        companyName: true,
+                        expiresAt: true,
+                        licenseKey: true,
                         userLimit: true,
                         isEvaluationLicense: true,
                     },
@@ -185,12 +191,24 @@ export default class EnterpriseLicenseAPI extends BaseAPI {
                         },
                     });
                 }
+                const terms = this.getLicenseTerms(license);
                 return Response.sendJsonObjectResponse(req, res, {
+                    companyName: terms.companyName,
+                    expiresAt: terms.expiresAt,
+                    licenseKey: terms.licenseKey,
+                    userLimit: terms.userLimit,
                     currentUserCount: currentUserCount,
                     userCountUpdatedAt: reportedAt.toISOString(),
-                    userLimit: typeof license.userLimit === "number" ? license.userLimit : null,
                     isEvaluationLicense: Boolean(license.isEvaluationLicense),
                     instances: this.getInstanceSummaries(instances),
+                    /*
+                     * Null once the license has expired. Unlike /validate this route
+                     * does not reject an expired license - the instance is still
+                     * expected to report, and the expiry notification emails are built
+                     * from what it reports - but it must not keep being handed a fresh
+                     * token, and the expiresAt above is what tells it the truth.
+                     */
+                    token: this.signLicenseToken(license),
                 });
             }
             catch (err) {
@@ -198,6 +216,42 @@ export default class EnterpriseLicenseAPI extends BaseAPI {
             }
         });
     }
+    /*
+     * The license terms a self-hosted installation mirrors locally. Built in one
+     * place so /validate and /report-user-count cannot drift: the seat limit was
+     * missing from what an instance could refresh for exactly as long as the two
+     * responses were written out by hand, separately.
+     */
+    getLicenseTerms(license) {
+        return {
+            companyName: license.companyName || "",
+            expiresAt: license.expiresAt ? license.expiresAt.toISOString() : null,
+            licenseKey: license.licenseKey || "",
+            userLimit: typeof license.userLimit === "number" ? license.userLimit : null,
+        };
+    }
+    /*
+     * Signed with the license server's own secret, so it is opaque to the
+     * installation holding it - it is the proof that oneuptime.com recognized
+     * the key, and the instance only checks that it exists. An expired license
+     * gets none, which is why this returns null rather than a short-lived token.
+     */
+    signLicenseToken(license) {
+        if (!license.expiresAt) {
+            return null;
+        }
+        const secondsUntilExpiry = Math.floor((license.expiresAt.getTime() - Date.now()) / 1000);
+        if (secondsUntilExpiry <= 0) {
+            return null;
+        }
+        const terms = this.getLicenseTerms(license);
+        return JSONWebToken.signJsonPayload({
+            companyName: terms.companyName,
+            expiresAt: terms.expiresAt,
+            licenseKey: terms.licenseKey,
+            userLimit: terms.userLimit,
+        }, Math.max(secondsUntilExpiry, 1));
+    }
     parseShortText(value) {
         if (typeof value !== "string") {
             return "";