@oneuptime/common 11.5.13 → 11.6.1

package/Tests/Utils/VersionUtil.test.ts

@@ -0,0 +1,348 @@
+import VersionUtil, { ParsedVersion } from "../../Utils/VersionUtil";
+
+describe("VersionUtil", () => {
+  describe("normalize", () => {
+    it("strips a leading v from a GitHub tag name", () => {
+      expect(VersionUtil.normalize("v11.5.13")).toBe("11.5.13");
+      expect(VersionUtil.normalize("V11.5.13")).toBe("11.5.13");
+    });
+
+    it("trims surrounding whitespace", () => {
+      expect(VersionUtil.normalize("  11.5.13\n")).toBe("11.5.13");
+    });
+
+    it("returns an empty string for non-strings", () => {
+      expect(VersionUtil.normalize(null)).toBe("");
+      expect(VersionUtil.normalize(undefined)).toBe("");
+      expect(VersionUtil.normalize(11)).toBe("");
+      expect(VersionUtil.normalize({ version: "1.0.0" })).toBe("");
+    });
+
+    it("caps absurdly long input", () => {
+      expect(VersionUtil.normalize("1".repeat(5000)).length).toBe(100);
+    });
+  });
+
+  describe("parse", () => {
+    it("parses a plain release", () => {
+      const parsed: ParsedVersion | null = VersionUtil.parse("11.5.13");
+
+      expect(parsed).toEqual({
+        major: 11,
+        minor: 5,
+        patch: 13,
+        prerelease: null,
+      });
+    });
+
+    it("parses a prerelease", () => {
+      const parsed: ParsedVersion | null = VersionUtil.parse("11.6.0-rc.1");
+
+      expect(parsed).toEqual({
+        major: 11,
+        minor: 6,
+        patch: 0,
+        prerelease: "rc.1",
+      });
+    });
+
+    it("discards build metadata, which takes no part in precedence", () => {
+      expect(VersionUtil.parse("11.5.13+abc123")?.prerelease).toBeNull();
+      expect(VersionUtil.compare("11.5.13+abc123", "11.5.13")).toBe(0);
+    });
+
+    it("returns null for partial, empty and garbage versions", () => {
+      const invalid: Array<unknown> = [
+        "11.5",
+        "11",
+        "",
+        "   ",
+        "latest",
+        "unknown",
+        "v",
+        "1.0.0.0",
+        "-1.0.0",
+        "1.0.0-",
+        null,
+        undefined,
+        11.5,
+        {},
+        [],
+      ];
+
+      for (const value of invalid) {
+        expect(VersionUtil.parse(value)).toBeNull();
+      }
+    });
+
+    it("rejects numbers too large to be a real version", () => {
+      expect(VersionUtil.parse("99999999999.0.0")).toBeNull();
+    });
+
+    it("reports validity", () => {
+      expect(VersionUtil.isValid("11.5.13")).toBe(true);
+      expect(VersionUtil.isValid("unknown")).toBe(false);
+    });
+  });
+
+  describe("canonicalize", () => {
+    it("rebuilds the version from its parts", () => {
+      expect(VersionUtil.canonicalize("11.5.13")).toBe("11.5.13");
+      expect(VersionUtil.canonicalize("v11.5.13")).toBe("11.5.13");
+      expect(VersionUtil.canonicalize("  11.6.0-rc.1 ")).toBe("11.6.0-rc.1");
+    });
+
+    /*
+     * A caller that validates with isValid() and then stores the string it
+     * passed in can end up storing "v11.5.13" for the input "vv11.5.13",
+     * because normalize() strips one "v" per call and isValid() normalizes a
+     * second time. canonicalize is the fix: it rebuilds from a single parse,
+     * so a doubled prefix is simply not a version and the result never carries
+     * a "v" for the UIs to double up on.
+     */
+    it("never returns a value that still carries a v prefix", () => {
+      expect(VersionUtil.canonicalize("vv11.5.13")).toBeNull();
+      expect(VersionUtil.canonicalize("vV11.5.13")).toBeNull();
+
+      for (const value of ["11.5.13", "v11.5.13", "  V11.5.13  "]) {
+        expect(VersionUtil.canonicalize(value)).toBe("11.5.13");
+      }
+    });
+
+    it("drops build metadata, which takes no part in precedence", () => {
+      expect(VersionUtil.canonicalize("11.5.13+abc123")).toBe("11.5.13");
+    });
+
+    it("is idempotent", () => {
+      const once: string | null = VersionUtil.canonicalize("v11.5.13");
+
+      expect(VersionUtil.canonicalize(once)).toBe(once);
+    });
+
+    it("returns null for anything that is not a version", () => {
+      expect(VersionUtil.canonicalize("unknown")).toBeNull();
+      expect(VersionUtil.canonicalize("")).toBeNull();
+      expect(VersionUtil.canonicalize(null)).toBeNull();
+      expect(VersionUtil.canonicalize("vvv1.2.3")).toBeNull();
+    });
+  });
+
+  describe("compare", () => {
+    it("orders by major, then minor, then patch", () => {
+      expect(VersionUtil.compare("10.0.0", "11.0.0")).toBe(-1);
+      expect(VersionUtil.compare("11.4.0", "11.5.0")).toBe(-1);
+      expect(VersionUtil.compare("11.5.12", "11.5.13")).toBe(-1);
+      expect(VersionUtil.compare("11.5.13", "11.5.12")).toBe(1);
+      expect(VersionUtil.compare("2.0.0", "10.0.0")).toBe(-1);
+    });
+
+    it("treats equal versions as equal regardless of a v prefix", () => {
+      expect(VersionUtil.compare("11.5.13", "v11.5.13")).toBe(0);
+    });
+
+    it("ranks a prerelease below the release of the same triple", () => {
+      expect(VersionUtil.compare("11.6.0-rc.1", "11.6.0")).toBe(-1);
+      expect(VersionUtil.compare("11.6.0", "11.6.0-rc.1")).toBe(1);
+    });
+
+    it("orders prerelease identifiers by semver precedence", () => {
+      expect(VersionUtil.compare("1.0.0-alpha", "1.0.0-alpha.1")).toBe(-1);
+      expect(VersionUtil.compare("1.0.0-alpha.1", "1.0.0-alpha.beta")).toBe(-1);
+      expect(VersionUtil.compare("1.0.0-alpha.beta", "1.0.0-beta")).toBe(-1);
+      expect(VersionUtil.compare("1.0.0-beta.2", "1.0.0-beta.11")).toBe(-1);
+      expect(VersionUtil.compare("1.0.0-rc.1", "1.0.0-rc.1")).toBe(0);
+    });
+
+    it("returns null when either side cannot be parsed", () => {
+      expect(VersionUtil.compare("unknown", "11.5.13")).toBeNull();
+      expect(VersionUtil.compare("11.5.13", "")).toBeNull();
+      expect(VersionUtil.compare(null, undefined)).toBeNull();
+    });
+
+    it("is antisymmetric across a range of pairs", () => {
+      const versions: Array<string> = [
+        "1.0.0",
+        "1.0.1",
+        "1.1.0",
+        "2.0.0",
+        "11.5.13",
+      ];
+
+      for (const a of versions) {
+        for (const b of versions) {
+          const forward: number = VersionUtil.compare(a, b) as number;
+          const reverse: number = VersionUtil.compare(b, a) as number;
+
+          // `|| 0` keeps the negation of 0 from producing -0, which toBe rejects.
+          expect(forward).toBe(-reverse || 0);
+        }
+      }
+    });
+  });
+
+  describe("isUpdateAvailable", () => {
+    it("is true only when the latest release is strictly newer", () => {
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.5.13",
+          latestVersion: "11.6.0",
+        }),
+      ).toBe(true);
+
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.5.13",
+          latestVersion: "v11.5.14",
+        }),
+      ).toBe(true);
+    });
+
+    it("is false when the installation is up to date", () => {
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.5.13",
+          latestVersion: "11.5.13",
+        }),
+      ).toBe(false);
+    });
+
+    it("never suggests a downgrade for a build ahead of the release", () => {
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.6.0",
+          latestVersion: "11.5.13",
+        }),
+      ).toBe(false);
+    });
+
+    it("never nudges a stable installation onto a prerelease", () => {
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.5.13",
+          latestVersion: "11.6.0-beta.1",
+        }),
+      ).toBe(false);
+    });
+
+    it("does tell a release candidate about the matching stable release", () => {
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.6.0-rc.1",
+          latestVersion: "11.6.0",
+        }),
+      ).toBe(true);
+    });
+
+    it("is false when the latest release is a prerelease of a new major", () => {
+      expect(
+        VersionUtil.isUpdateAvailable({
+          currentVersion: "11.5.13",
+          latestVersion: "12.0.0-rc.1",
+        }),
+      ).toBe(false);
+    });
+
+    it("is false whenever either version is unknown or missing", () => {
+      const unknownValues: Array<unknown> = [
+        "unknown",
+        "",
+        null,
+        undefined,
+        "latest",
+        42,
+      ];
+
+      for (const value of unknownValues) {
+        expect(
+          VersionUtil.isUpdateAvailable({
+            currentVersion: value,
+            latestVersion: "11.6.0",
+          }),
+        ).toBe(false);
+
+        expect(
+          VersionUtil.isUpdateAvailable({
+            currentVersion: "11.5.13",
+            latestVersion: value,
+          }),
+        ).toBe(false);
+      }
+    });
+  });
+
+  describe("isMajorUpgrade", () => {
+    it("is true only when the update crosses a major version", () => {
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "11.5.13",
+          latestVersion: "12.0.0",
+        }),
+      ).toBe(true);
+
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "10.9.9",
+          latestVersion: "12.0.0",
+        }),
+      ).toBe(true);
+    });
+
+    it("is false for a minor or patch update", () => {
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "11.5.13",
+          latestVersion: "11.6.0",
+        }),
+      ).toBe(false);
+
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "11.5.13",
+          latestVersion: "11.5.14",
+        }),
+      ).toBe(false);
+    });
+
+    it("is false when there is no update to take at all", () => {
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "12.0.0",
+          latestVersion: "12.0.0",
+        }),
+      ).toBe(false);
+
+      // Ahead of the release — a new major behind us is still not an upgrade.
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "12.1.0",
+          latestVersion: "11.9.9",
+        }),
+      ).toBe(false);
+    });
+
+    it("is false when the new major is only a prerelease", () => {
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "11.5.13",
+          latestVersion: "12.0.0-rc.1",
+        }),
+      ).toBe(false);
+    });
+
+    it("is false whenever either version is unknown or missing", () => {
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "unknown",
+          latestVersion: "12.0.0",
+        }),
+      ).toBe(false);
+
+      expect(
+        VersionUtil.isMajorUpgrade({
+          currentVersion: "11.5.13",
+          latestVersion: null,
+        }),
+      ).toBe(false);
+    });
+  });
+});

package/Tests/jest.setup.ts

@@ -1,4 +1,5 @@
 import "@testing-library/jest-dom";
+import { jest } from "@jest/globals";
 import { TextEncoder, TextDecoder } from "util";
 import { webcrypto, randomUUID } from "crypto";
 

package/Types/AnalyticsDatabase/TableColumn.ts

@@ -213,6 +213,27 @@ export default class AnalyticsTableColumn {
     this._aggregateFunctionDefinition = v;
   }
 
+  /*
+   * Optional ClickHouse SimpleAggregateFunction wrapper for scalar columns.
+   *
+   * Unlike AggregateFunction, a SimpleAggregateFunction keeps the scalar's
+   * ordinary wire/query type (for example DateTime) while teaching
+   * AggregatingMergeTree how to combine values during background merges.
+   * `max` on a DateTime retention column is the canonical use: reads and TTLs
+   * still see a DateTime, but rows sharing the sort key retain the latest
+   * expiry instead of an arbitrary one.
+   *
+   * The underlying type comes from `type`; this field contains only the
+   * function name, e.g. "max".
+   */
+  private _simpleAggregateFunction: string | undefined;
+  public get simpleAggregateFunction(): string | undefined {
+    return this._simpleAggregateFunction;
+  }
+  public set simpleAggregateFunction(v: string | undefined) {
+    this._simpleAggregateFunction = v;
+  }
+
   public constructor(data: {
     key: string;
     title: string;
@@ -232,6 +253,7 @@ export default class AnalyticsTableColumn {
     isLowCardinality?: boolean | undefined;
     mapKeysColumn?: string | undefined;
     aggregateFunctionDefinition?: string | undefined;
+    simpleAggregateFunction?: string | undefined;
   }) {
     this.accessControl = data.accessControl;
     this.key = data.key;
@@ -250,5 +272,6 @@ export default class AnalyticsTableColumn {
     this.isLowCardinality = data.isLowCardinality || false;
     this.mapKeysColumn = data.mapKeysColumn;
     this.aggregateFunctionDefinition = data.aggregateFunctionDefinition;
+    this.simpleAggregateFunction = data.simpleAggregateFunction;
   }
 }

package/Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary.ts

@@ -13,6 +13,12 @@ type EnterpriseLicenseInstanceSummary = {
   userCount: number | null;
   // ISO date string of the most recent usage report from this instance.
   lastReportedAt: string | null;
+  /*
+   * OneUptime version this instance last reported, for example "11.5.13".
+   * Null for instances that have not reported since upgrading to a build
+   * that sends its version, and for dev builds with no APP_VERSION baked in.
+   */
+  version: string | null;
 };
 
 export default EnterpriseLicenseInstanceSummary;

package/Types/Monitor/MonitorStep.ts

@@ -302,10 +302,30 @@ export default class MonitorStep extends DatabaseProperty {
       retryCountOnError: undefined,
       requestTimeoutInMs: undefined,
       retryCount: undefined,
-      logMonitor: undefined,
-      traceMonitor: undefined,
-      metricMonitor: undefined,
-      exceptionMonitor: undefined,
+      /*
+       * Seed the telemetry sub-config for the monitor's OWN type so a
+       * monitor saved on defaults (without the user touching the telemetry
+       * sub-form) still persists a usable query config. Without this the
+       * sub-config stayed undefined and the worker threw "<type> query/config
+       * is missing" on every evaluation, so the monitor never ran. Only the
+       * matching type is seeded; every other type stays undefined.
+       */
+      logMonitor:
+        arg.monitorType === MonitorType.Logs
+          ? MonitorStepLogMonitorUtil.getDefault()
+          : undefined,
+      traceMonitor:
+        arg.monitorType === MonitorType.Traces
+          ? MonitorStepTraceMonitorUtil.getDefault()
+          : undefined,
+      metricMonitor:
+        arg.monitorType === MonitorType.Metrics
+          ? MonitorStepMetricMonitorUtil.getDefault()
+          : undefined,
+      exceptionMonitor:
+        arg.monitorType === MonitorType.Exceptions
+          ? MonitorStepExceptionMonitorUtil.getDefault()
+          : undefined,
       profileMonitor: undefined,
       snmpMonitor: undefined,
       networkDeviceMonitor: undefined,

package/Types/Monitor/MonitorStepMetricViewConfigUtil.ts

@@ -0,0 +1,105 @@
+import MetricFormulaConfigData from "../Metrics/MetricFormulaConfigData";
+import MetricQueryConfigData from "../Metrics/MetricQueryConfigData";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import { MonitorStepType } from "./MonitorStep";
+
+/**
+ * Every monitor-step data key that carries a `metricViewConfig`. These are the
+ * "metric-shaped" monitor types — the ones whose alert criteria evaluate a
+ * metric query (CheckOn.MetricValue). The order here is not significant; a
+ * given monitor step only ever populates one of these keys.
+ *
+ * Keeping this list in one place is what prevents the class of bug where a new
+ * metric-shaped monitor type (e.g. Host, Podman, DockerSwarm, IoT) is wired
+ * into the step form but forgotten in the criteria UI, leaving the "Which
+ * metric query should this alert rule check?" dropdown blank ("No options").
+ */
+const METRIC_VIEW_CONFIG_KEYS: Array<keyof MonitorStepType> = [
+  "metricMonitor",
+  "hostMonitor",
+  "kubernetesMonitor",
+  "dockerMonitor",
+  "dockerSwarmMonitor",
+  "podmanMonitor",
+  "proxmoxMonitor",
+  "cephMonitor",
+  "iotMonitor",
+];
+
+export default class MonitorStepMetricViewConfigUtil {
+  /**
+   * Resolve the `metricViewConfig` from whichever metric-shaped monitor sub-config
+   * is populated on this monitor step. Returns undefined when the step is not
+   * metric-shaped (or none of the metric configs is present).
+   */
+  public static getMetricViewConfig(
+    monitorStepData: MonitorStepType | undefined,
+  ): MetricsViewConfig | undefined {
+    if (!monitorStepData) {
+      return undefined;
+    }
+
+    /*
+     * Each metric-shaped sub-config is an object with an optional
+     * `metricViewConfig`. Index through a record view so the lookup stays
+     * data-driven (see METRIC_VIEW_CONFIG_KEYS) without fighting the wide
+     * union of MonitorStepType's value types.
+     */
+    const stepRecord: Record<
+      string,
+      { metricViewConfig?: MetricsViewConfig } | undefined
+    > = monitorStepData as unknown as Record<
+      string,
+      { metricViewConfig?: MetricsViewConfig } | undefined
+    >;
+
+    for (const key of METRIC_VIEW_CONFIG_KEYS) {
+      const subConfig: { metricViewConfig?: MetricsViewConfig } | undefined =
+        stepRecord[key];
+
+      if (subConfig?.metricViewConfig) {
+        return subConfig.metricViewConfig;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Collect the distinct, non-empty metric variables (aliases) from the step's
+   * query configs and formula configs. These become the options for the
+   * criteria "Metric" dropdown. Empty variables are dropped and duplicates are
+   * removed while preserving first-seen order.
+   */
+  public static getMetricVariables(
+    monitorStepData: MonitorStepType | undefined,
+  ): Array<string> {
+    const metricViewConfig: MetricsViewConfig | undefined =
+      this.getMetricViewConfig(monitorStepData);
+
+    if (!metricViewConfig) {
+      return [];
+    }
+
+    const variables: Array<string> = [];
+
+    for (const queryConfig of metricViewConfig.queryConfigs || []) {
+      variables.push(
+        (queryConfig as MetricQueryConfigData).metricAliasData
+          ?.metricVariable || "",
+      );
+    }
+
+    for (const formulaConfig of metricViewConfig.formulaConfigs || []) {
+      variables.push(
+        (formulaConfig as MetricFormulaConfigData).metricAliasData
+          ?.metricVariable || "",
+      );
+    }
+
+    // Remove duplicates (first-seen order) and drop empty strings.
+    return variables.filter((item: string, index: number): boolean => {
+      return variables.indexOf(item) === index && item !== "";
+    });
+  }
+}