@oneuptime/common 11.5.12 → 11.6.0

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/AI/CodeFixTaskContext.ts

@@ -83,6 +83,12 @@ export interface CodeFixTaskContext {
   performanceFindings?: Array<PerformanceFinding> | undefined;
   // code.* attribute locations for stack-trace-style repo resolution.
   codeLocations?: Array<PerformanceCodeLocation> | undefined;
+  /*
+   * ImproveLogging / ImproveTracing: the telemetry service whose
+   * instrumentation the recipe improves (serviceName above carries its
+   * name for repository resolution and PR wording).
+   */
+  telemetryServiceId?: string | undefined;
 }
 
 export default CodeFixTaskContext;

package/Types/AI/CodeFixTaskType.ts

@@ -12,6 +12,16 @@ enum CodeFixTaskType {
   FixException = "FixException",
   // Write a failing-then-passing regression test that reproduces the exception.
   WriteRegressionTest = "WriteRegressionTest",
+  /*
+   * Improve how the code HANDLES and REPORTS this exception without
+   * changing business behavior: parameterize messages that interpolate
+   * user data (PII out of error text, stable fingerprints), validate bad
+   * input earlier with an actionable error, and mark expected/operational
+   * errors as handled in telemetry. The recipe for exceptions the triage
+   * classified as user errors or expected denials — where "fix the bug"
+   * is the wrong instruction because there is no bug.
+   */
+  ImproveExceptionHandling = "ImproveExceptionHandling",
   /*
    * Add the observability an INCONCLUSIVE AI investigation was missing
    * (structured logs, spans, metric counters on the implicated code paths).
@@ -32,6 +42,27 @@ enum CodeFixTaskType {
    * Common/Server/Utils/AI/SRE/FixPerformanceTaskTrigger.ts).
    */
   FixPerformance = "FixPerformance",
+  /*
+   * Improve a SERVICE's logging hygiene: structured/parameterized log
+   * messages (no user data interpolated into log text), correct severity
+   * levels, trace correlation, proper exception recording instead of raw
+   * stack dumps in log bodies, and less noise. Human-triggered from the
+   * service's Logs page (POST /ai-investigation/
+   * create-telemetry-improvement-task); its context (service id + name) is
+   * captured into AIRun.taskContext at trigger time. Instrumentation only —
+   * never a behavior change.
+   */
+  ImproveLogging = "ImproveLogging",
+  /*
+   * Improve a SERVICE's tracing instrumentation: spans on uninstrumented
+   * entry points and significant operations, low-cardinality span names,
+   * exceptions recorded on spans with correct status/escaped semantics,
+   * code.* and semantic-convention attributes, context propagation across
+   * async boundaries. Human-triggered from the service's Traces page (same
+   * endpoint as ImproveLogging); context captured into AIRun.taskContext.
+   * Instrumentation only — never a behavior change.
+   */
+  ImproveTracing = "ImproveTracing",
   /*
    * Fix the root cause a completed AI investigation identified. Human-
    * triggered from the investigation panel (POST /ai-investigation/
@@ -77,7 +108,11 @@ export class CodeFixTaskTypeHelper {
    * (POST /ai-investigation/create-performance-fix-task).
    */
   public static getUserTriggerableTaskTypes(): Array<CodeFixTaskType> {
-    return [CodeFixTaskType.FixException, CodeFixTaskType.WriteRegressionTest];
+    return [
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.WriteRegressionTest,
+      CodeFixTaskType.ImproveExceptionHandling,
+    ];
   }
 
   public static isUserTriggerable(taskType: CodeFixTaskType): boolean {
@@ -97,6 +132,8 @@ export class CodeFixTaskTypeHelper {
       case CodeFixTaskType.FixFromIncident:
         return CodeFixContextKind.IncidentOrAlertSubject;
       case CodeFixTaskType.FixPerformance:
+      case CodeFixTaskType.ImproveLogging:
+      case CodeFixTaskType.ImproveTracing:
         return CodeFixContextKind.TaskContext;
       default:
         return CodeFixContextKind.TelemetryException;

package/Types/AI/ExceptionAIClassification.ts

@@ -0,0 +1,27 @@
+/*
+ * AI triage verdict for a telemetry exception group. Decides how the
+ * automatic fix lane treats the group:
+ *
+ * - CodeFault: a defect in the monitored code — the only class the
+ *   automatic lane opens fix pull requests for.
+ * - UserError: expected consequence of invalid end-user input (bad
+ *   parameters, malformed values). The right change, if any, is earlier
+ *   validation and clearer error UX — routed to a human, never auto-fixed.
+ * - ExpectedDenial: an intentional check doing its job (auth failure,
+ *   plan/paywall denial, scanner/fuzzer probe tripping validation).
+ *   Never auto-fixed; optionally auto-archived.
+ * - Infrastructure: environmental conditions (timeouts, connection
+ *   resets, resource exhaustion) where a code "fix" is usually tuning —
+ *   routed to a human.
+ * - Unknown: triage could not decide — treated conservatively (no
+ *   automatic fix).
+ */
+enum ExceptionAIClassification {
+  CodeFault = "code-fault",
+  UserError = "user-error",
+  ExpectedDenial = "expected-denial",
+  Infrastructure = "infrastructure",
+  Unknown = "unknown",
+}
+
+export default ExceptionAIClassification;

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/Log/LogScrubPatternType.ts

@@ -4,6 +4,13 @@ enum LogScrubPatternType {
   SSN = "ssn",
   PhoneNumber = "phoneNumber",
   IPAddress = "ipAddress",
+  /*
+   * Key-targeted: scrubs the WHOLE value of any attribute whose KEY looks
+   * sensitive (password, token, apiKey, authorization, cookie, ...) —
+   * catches secrets whose values match no shape-based pattern. Applies to
+   * attributes only; body text has no keys to match.
+   */
+  SensitiveKeys = "sensitiveKeys",
   Custom = "custom",
 }
 

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 !== "";
+    });
+  }
+}

package/Types/Trace/TraceScrubPatternType.ts

@@ -4,6 +4,13 @@ enum TraceScrubPatternType {
   SSN = "ssn",
   PhoneNumber = "phoneNumber",
   IPAddress = "ipAddress",
+  /*
+   * Key-targeted: scrubs the WHOLE value of any attribute whose KEY looks
+   * sensitive (password, token, apiKey, authorization, cookie, ...) —
+   * catches secrets whose values match no shape-based pattern. Applies to
+   * span/event attributes only; span names have no keys to match.
+   */
+  SensitiveKeys = "sensitiveKeys",
   Custom = "custom",
 }