@oneuptime/common 11.5.11 → 11.5.13

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/BaseDatabase/GreaterThan.ts

@@ -11,7 +11,14 @@ export default class GreaterThan<T extends CompareType> extends CompareBase<T> {
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.GreaterThan,
-      value: (this as GreaterThan<T>).toString(),
+      /*
+       * The RAW value is serialized (like InBetween), not toString():
+       * toString() collapses a Date to a local-timezone date-only string
+       * (asDateForDatabaseQuery), shifting Date bounds sent from the browser
+       * by up to a day. JSON.stringify emits a raw Date as its full ISO
+       * timestamp, which the server binds at full precision.
+       */
+      value: (this as GreaterThan<T>).value,
     };
   }
 

package/Types/BaseDatabase/GreaterThanOrEqual.ts

@@ -13,7 +13,14 @@ export default class GreaterThanOrEqual<
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.GreaterThanOrEqual,
-      value: (this as GreaterThanOrEqual<T>).toString(),
+      /*
+       * The RAW value is serialized (like InBetween), not toString():
+       * toString() collapses a Date to a local-timezone date-only string
+       * (asDateForDatabaseQuery), shifting Date bounds sent from the browser
+       * by up to a day. JSON.stringify emits a raw Date as its full ISO
+       * timestamp, which the server binds at full precision.
+       */
+      value: (this as GreaterThanOrEqual<T>).value,
     };
   }
 

package/Types/BaseDatabase/GreaterThanOrNull.ts

@@ -10,10 +10,18 @@ export default class GreaterThanOrNull<
     super(value);
   }
 
+  /*
+   * Serializes the RAW value (like InBetween does), not toString(): toString()
+   * collapses a Date to a date-only string in the LOCAL timezone
+   * (asDateForDatabaseQuery), so a Date bound would arrive at the server as
+   * midnight of the browser's calendar date and shift the query bound by up to
+   * a day. JSON.stringify turns a raw Date into its full ISO timestamp, which
+   * the server binds at full precision.
+   */
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.GreaterThanOrNull,
-      value: (this as GreaterThanOrNull<T>).toString(),
+      value: (this as GreaterThanOrNull<T>).value,
     };
   }
 

package/Types/BaseDatabase/LessThan.ts

@@ -11,7 +11,14 @@ export default class LessThan<T extends CompareType> extends CompareBase<T> {
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.LessThan,
-      value: (this as LessThan<T>).toString(),
+      /*
+       * The RAW value is serialized (like InBetween), not toString():
+       * toString() collapses a Date to a local-timezone date-only string
+       * (asDateForDatabaseQuery), shifting Date bounds sent from the browser
+       * by up to a day. JSON.stringify emits a raw Date as its full ISO
+       * timestamp, which the server binds at full precision.
+       */
+      value: (this as LessThan<T>).value,
     };
   }
 

package/Types/BaseDatabase/LessThanOrEqual.ts

@@ -10,10 +10,18 @@ export default class LessThanOrEqual<
     super(value);
   }
 
+  /*
+   * Serializes the RAW value (like InBetween does), not toString(): toString()
+   * collapses a Date to a date-only string in the LOCAL timezone
+   * (asDateForDatabaseQuery), so a bound of "now" would arrive at the server as
+   * midnight of the browser's calendar date and silently exclude every row from
+   * today. JSON.stringify turns a raw Date into its full ISO timestamp, which
+   * the server binds at full precision.
+   */
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.LessThanOrEqual,
-      value: (this as LessThanOrEqual<T>).toString(),
+      value: (this as LessThanOrEqual<T>).value,
     };
   }
 

package/Types/BaseDatabase/LessThanOrNull.ts

@@ -13,7 +13,14 @@ export default class LessThanOrNull<
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.LessThanOrNull,
-      value: (this as LessThanOrNull<T>).toString(),
+      /*
+       * The RAW value is serialized (like InBetween), not toString():
+       * toString() collapses a Date to a local-timezone date-only string
+       * (asDateForDatabaseQuery), shifting Date bounds sent from the browser
+       * by up to a day. JSON.stringify emits a raw Date as its full ISO
+       * timestamp, which the server binds at full precision.
+       */
+      value: (this as LessThanOrNull<T>).value,
     };
   }
 

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/Utils/StatusPage/ResourceUptime.ts

@@ -6,7 +6,7 @@ import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
 import Dictionary from "../../Types/Dictionary";
 import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
 import StatusPageGroup from "../../Models/DatabaseModels/StatusPageGroup";
-import UptimeUtil from "../Uptime/UptimeUtil";
+import UptimeUtil, { UptimeWindow } from "../Uptime/UptimeUtil";
 
 export default class StatusPageResourceUptimeUtil {
   public static getWorstMonitorStatus(data: {
@@ -137,6 +137,8 @@ export default class StatusPageResourceUptimeUtil {
     precision: UptimePrecision;
     downtimeMonitorStatuses: Array<MonitorStatus>;
     monitorsInGroup: Dictionary<Array<ObjectID>>;
+    // if supplied, uptime is measured over this window instead of "first event -> now".
+    uptimeWindow?: UptimeWindow | undefined;
   }): number | null {
     if (!data.statusPageResource.showUptimePercent) {
       return null;
@@ -156,6 +158,7 @@ export default class StatusPageResourceUptimeUtil {
       monitorStatusTimelines,
       data.precision,
       downtimeMonitorStatuses,
+      data.uptimeWindow,
     );
 
     return uptimePercent;
@@ -168,6 +171,8 @@ export default class StatusPageResourceUptimeUtil {
     downtimeMonitorStatuses: Array<MonitorStatus>;
     statusPageResources: Array<StatusPageResource>;
     monitorsInGroup: Dictionary<Array<ObjectID>>;
+    // if supplied, uptime is measured over this window instead of "first event -> now".
+    uptimeWindow?: UptimeWindow | undefined;
   }): number | null {
     if (!data.statusPageGroup.showUptimePercent) {
       return null;
@@ -193,6 +198,7 @@ export default class StatusPageResourceUptimeUtil {
           precision: data.precision,
           downtimeMonitorStatuses: data.downtimeMonitorStatuses,
           monitorsInGroup: data.monitorsInGroup,
+          uptimeWindow: data.uptimeWindow,
         });
 
       if (calculateUptimePercentOfResource !== null) {
@@ -252,6 +258,8 @@ export default class StatusPageResourceUptimeUtil {
     statusPageResources: Array<StatusPageResource>;
     resourceGroups: Array<StatusPageGroup>;
     monitorsInGroup: Dictionary<Array<ObjectID>>;
+    // if supplied, uptime is measured over this window instead of "first event -> now".
+    uptimeWindow?: UptimeWindow | undefined;
   }): number | null {
     const showUptimePercentage: boolean = Boolean(
       data.statusPageResources.find((item: StatusPageResource) => {
@@ -276,6 +284,7 @@ export default class StatusPageResourceUptimeUtil {
           downtimeMonitorStatuses: data.downtimeMonitorStatuses,
           statusPageResources: data.statusPageResources,
           monitorsInGroup: data.monitorsInGroup,
+          uptimeWindow: data.uptimeWindow,
         });
 
       if (calculateAvgUptimePercentOfStatusPageGroup !== null) {
@@ -298,6 +307,7 @@ export default class StatusPageResourceUptimeUtil {
           precision: data.precision,
           downtimeMonitorStatuses: data.downtimeMonitorStatuses,
           monitorsInGroup: data.monitorsInGroup,
+          uptimeWindow: data.uptimeWindow,
         });
 
       if (calculateUptimePercentOfResource !== null) {