@oneuptime/common 11.5.12 → 11.5.13

package/Tests/UI/Components/ModelTableSelectFromColumns.test.ts

@@ -0,0 +1,259 @@
+import Columns from "../../../UI/Components/ModelTable/Columns";
+import {
+  getRelationSelectFromColumns,
+  getSelectFromColumns,
+} from "../../../UI/Components/ModelTable/SelectFromColumns";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import Alert from "../../../Models/DatabaseModels/Alert";
+import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ModelTable SelectFromColumns", () => {
+  describe("getSelectFromColumns", () => {
+    test("it selects every field a column declares, not just the first", () => {
+      /*
+       * Regression for OneUptime/oneuptime#2756: the Proxmox clusters list
+       * rendered "0/3 online" for a fully online cluster because only the
+       * first key of the column's field map was selected, leaving
+       * onlineNodeCount undefined on every row.
+       */
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBe(true);
+    });
+
+    test("it always selects _id", () => {
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: [],
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["_id"]).toBe(true);
+    });
+
+    test("it merges fields across multiple columns", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { name: true },
+          title: "Name",
+          type: FieldType.Text,
+        },
+        {
+          field: { guestCount: true, storageCount: true },
+          title: "Inventory",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["name"]).toBe(true);
+      expect(select["guestCount"]).toBe(true);
+      expect(select["storageCount"]).toBe(true);
+    });
+
+    test("it skips columns that declare no field", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: undefined as never,
+          title: "Actions",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(Object.keys(select)).toEqual(["_id"]);
+    });
+
+    test("it throws when the primary field is not a column on the model", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { notARealColumn: true } as never,
+          title: "Nope",
+          type: FieldType.Text,
+        },
+      ];
+
+      expect(() => {
+        return getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("it ignores a non-column secondary field rather than blanking the page", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { nodeCount: true, notARealColumn: true } as never,
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const consoleError: jest.SpyInstance = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["notARealColumn"]).toBeUndefined();
+      // It must not drop the field silently — that is how #2756 hid.
+      expect(consoleError).toHaveBeenCalled();
+
+      consoleError.mockRestore();
+    });
+
+    test("it drops a secondary field the user cannot read, so the API does not reject the whole request", () => {
+      /*
+       * checkSelectPermission throws NotAuthorizedException for the entire
+       * request when the select names an unreadable column, so widening the
+       * select must never add one.
+       */
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+          hasPermissionToReadField: (field: string): boolean => {
+            return field !== "onlineNodeCount";
+          },
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBeUndefined();
+    });
+
+    test("it keeps the primary field even when the permission callback rejects it, preserving prior behaviour", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { nodeCount: true, onlineNodeCount: true },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+          hasPermissionToReadField: (): boolean => {
+            return false;
+          },
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBeUndefined();
+    });
+  });
+
+  describe("getRelationSelectFromColumns", () => {
+    test("it selects every relation a column declares, not just the first", () => {
+      const columns: Columns<Alert> = [
+        {
+          field: {
+            monitor: { name: true, _id: true },
+            labels: { name: true, color: true },
+          },
+          title: "Resource",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<Alert>({
+          columns: columns,
+          model: new Alert(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect["monitor"]).toEqual({ name: true, _id: true });
+      expect(relationSelect["labels"]).toEqual({ name: true, color: true });
+    });
+
+    test("it leaves non-entity fields out of the relation select", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect).toEqual({});
+    });
+
+    test("it merges the same relation declared by two columns", () => {
+      const columns: Columns<Alert> = [
+        {
+          field: { monitor: { name: true } },
+          title: "Monitor",
+          type: FieldType.Element,
+        },
+        {
+          field: { monitor: { _id: true } },
+          title: "Monitor Id",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<Alert>({
+          columns: columns,
+          model: new Alert(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect["monitor"]).toEqual({ name: true, _id: true });
+    });
+  });
+});

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/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/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",
 }
 

package/UI/Components/ModelTable/BaseModelTable.tsx

@@ -53,6 +53,10 @@ import TableColumn from "../Table/Types/Column";
 import FieldType from "../Types/FieldType";
 import ModelTableColumn from "./Column";
 import Columns from "./Columns";
+import {
+  getRelationSelectFromColumns,
+  getSelectFromColumns,
+} from "./SelectFromColumns";
 import AnalyticsBaseModel, {
   AnalyticsBaseModelType,
 } from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
@@ -664,33 +668,10 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
 
   const getRelationSelect: GetRelationSelectFunction =
     (): Select<TBaseModel> => {
-      const relationSelect: Select<TBaseModel> = {};
-
-      for (const column of props.columns || []) {
-        const key: string | null = column.field
-          ? (Object.keys(column.field)[0] as string)
-          : null;
-
-        if (key && model.isFileColumn(key)) {
-          (relationSelect as JSONObject)[key] = {
-            file: true,
-            _id: true,
-            fileType: true,
-            name: true,
-          };
-        } else if (key && model.isEntityColumn(key)) {
-          if (!(relationSelect as JSONObject)[key]) {
-            (relationSelect as JSONObject)[key] = {};
-          }
-
-          (relationSelect as JSONObject)[key] = {
-            ...((relationSelect as JSONObject)[key] as JSONObject),
-            ...(column.field as any)[key],
-          };
-        }
-      }
-
-      return relationSelect;
+      return getRelationSelectFromColumns<TBaseModel>({
+        columns: props.columns || [],
+        model: model,
+      });
     };
 
   type DeleteItemFunction = (item: TBaseModel) => Promise<void>;
@@ -1226,25 +1207,13 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
   type GetSelectFunction = () => Select<TBaseModel>;
 
   const getSelect: GetSelectFunction = (): Select<TBaseModel> => {
-    const selectFields: Select<TBaseModel> = {
-      _id: true,
-    };
-
-    for (const column of props.columns || []) {
-      const key: string | null = column.field
-        ? (Object.keys(column.field)[0] as string)
-        : null;
-
-      if (key) {
-        if (model.hasColumn(key)) {
-          (selectFields as Dictionary<boolean>)[key] = true;
-        } else {
-          throw new BadDataException(
-            `${key} column not found on ${model.singularName}`,
-          );
-        }
-      }
-    }
+    const selectFields: Select<TBaseModel> = getSelectFromColumns<TBaseModel>({
+      columns: props.columns || [],
+      model: model,
+      hasPermissionToReadField: (field: string): boolean => {
+        return hasPermissionToReadField(field as keyof TBaseModel);
+      },
+    });
 
     const selectMoreFields: Array<keyof TBaseModel> = props.selectMoreFields
       ? (Object.keys(props.selectMoreFields) as Array<keyof TBaseModel>)

package/UI/Components/ModelTable/SelectFromColumns.ts

@@ -0,0 +1,129 @@
+import Columns from "./Columns";
+import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Select from "../../../Types/BaseDatabase/Select";
+import Dictionary from "../../../Types/Dictionary";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { Logger } from "../../Utils/Logger";
+
+/*
+ * Builds the API `select` for a ModelTable from its column definitions.
+ *
+ * A column may declare MORE THAN ONE field when its cell renders a value
+ * composed from several columns — e.g. a "Nodes" cell that renders
+ * `{onlineNodeCount}/{nodeCount} online` declares
+ * `field: { nodeCount: true, onlineNodeCount: true }`.
+ *
+ * These used to select only the FIRST key, which left every other declared
+ * field `undefined` on the fetched row, so such cells silently rendered
+ * their zero/empty fallback — a fully online Proxmox cluster displayed
+ * "0/3 online" (OneUptime/oneuptime#2756). ModelDetail has always selected
+ * every declared key; these helpers keep ModelTable in sync with it.
+ */
+
+export function getSelectFromColumns<
+  TBaseModel extends BaseModel | AnalyticsBaseModel,
+>(data: {
+  columns: Columns<TBaseModel>;
+  model: TBaseModel;
+  /*
+   * Secondary fields are gated on this. The API rejects the WHOLE request
+   * with NotAuthorizedException when the select names a column the caller
+   * cannot read (Common/Server/Types/Database/Permissions/SelectPermission
+   * .checkSelectPermission), so a secondary field the user has no read
+   * permission on must be dropped rather than blank the table for them.
+   * Primary fields are left exactly as they always were.
+   */
+  hasPermissionToReadField?: ((field: string) => boolean) | undefined;
+}): Select<TBaseModel> {
+  const selectFields: Select<TBaseModel> = {
+    _id: true,
+  };
+
+  for (const column of data.columns) {
+    if (!column.field) {
+      continue;
+    }
+
+    const keys: Array<string> = Object.keys(column.field);
+
+    for (const key of keys) {
+      const isPrimaryField: boolean = key === keys[0];
+
+      if (!data.model.hasColumn(key)) {
+        if (isPrimaryField) {
+          /*
+           * Only the primary field is a hard error — it is also the key
+           * used for sorting and for the default cell renderer, so a bad
+           * one is a genuine mistake.
+           */
+          throw new BadDataException(
+            `${key} column not found on ${data.model.singularName}`,
+          );
+        }
+
+        /*
+         * A stray secondary key degrades to "not selected" rather than
+         * throwing, because throwing here blanks the entire page. Log it:
+         * silently dropping it is what produced #2756 in the first place.
+         */
+        Logger.error(
+          `ModelTable column "${column.title}" on ${data.model.singularName} declares field "${key}", which is not a column on the model. It will not be fetched, so the cell will render its empty value.`,
+        );
+        continue;
+      }
+
+      if (
+        !isPrimaryField &&
+        data.hasPermissionToReadField &&
+        !data.hasPermissionToReadField(key)
+      ) {
+        continue;
+      }
+
+      (selectFields as Dictionary<boolean>)[key] = true;
+    }
+  }
+
+  return selectFields;
+}
+
+export function getRelationSelectFromColumns<
+  TBaseModel extends BaseModel | AnalyticsBaseModel,
+>(data: {
+  columns: Columns<TBaseModel>;
+  model: TBaseModel;
+}): Select<TBaseModel> {
+  const relationSelect: Select<TBaseModel> = {};
+
+  for (const column of data.columns) {
+    if (!column.field) {
+      continue;
+    }
+
+    /*
+     * Same multi-field contract as getSelectFromColumns: one cell can
+     * render several relations (e.g. an alert "Resource" cell spanning
+     * hosts / kubernetesClusters / dockerHosts / podmanHosts / services).
+     */
+    for (const key of Object.keys(column.field)) {
+      if (data.model.isFileColumn(key)) {
+        (relationSelect as JSONObject)[key] = {
+          file: true,
+          _id: true,
+          fileType: true,
+          name: true,
+        };
+      } else if (data.model.isEntityColumn(key)) {
+        (relationSelect as JSONObject)[key] = {
+          ...(((relationSelect as JSONObject)[key] as JSONObject) || {}),
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ...((column.field as any)[key] as JSONObject),
+        };
+      }
+    }
+  }
+
+  return relationSelect;
+}

package/build/dist/Models/DatabaseModels/AIInsight.js

@@ -48,6 +48,13 @@ let AIInsight = class AIInsight extends BaseModel {
         this.insightType = undefined;
         this.status = undefined;
         this.severity = undefined;
+        /*
+         * Triage verdict (ExceptionAIClassification values) written by the
+         * insight triage runner. Null until triage completes. The automatic
+         * fix lane only opens pull requests for insights triaged as
+         * code-fault — see InsightScanner / InsightFixRouting.
+         */
+        this.classification = undefined;
         /*
          * The detector's stable dedupe key for this finding (e.g.
          * "new-exception:<telemetryExceptionId>"). The scanner refreshes the
@@ -225,6 +232,30 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], AIInsight.prototype, "severity", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+        ],
+        update: [],
+    }),
+    TableColumn({
+        required: false,
+        type: TableColumnType.ShortText,
+        title: "Classification",
+        description: "AI triage verdict: code-fault, user-error, expected-denial, infrastructure or unknown. Automatic fix pull requests are only opened for code-fault.",
+        canReadOnRelationQuery: true,
+    }),
+    Column({
+        nullable: true,
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+    }),
+    __metadata("design:type", String)
+], AIInsight.prototype, "classification", void 0);
 __decorate([
     ColumnAccessControl({
         create: [],