@oneuptime/common 12.0.4 → 12.0.5

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 StatusPageGroupTreeUtil from "./GroupTree";
+import StatusPageGroupTreeUtil, { StatusPageGroupTreeIndex } from "./GroupTree";
 import UptimeUtil, { UptimeWindow } from "../Uptime/UptimeUtil";
 
 export default class StatusPageResourceUptimeUtil {
@@ -81,6 +81,12 @@ export default class StatusPageResourceUptimeUtil {
      * (or pass only this group) to look at the group's own resources.
      */
     allStatusPageGroups?: Array<StatusPageGroup> | undefined;
+    /*
+     * A prebuilt parent -> children index over allStatusPageGroups. Optional,
+     * and worth passing from any caller that asks this per group: without it
+     * every call re-buckets the whole group list.
+     */
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
   }): MonitorStatus {
     let currentStatus: MonitorStatus = new MonitorStatus();
     currentStatus.name = "Operational";
@@ -91,6 +97,7 @@ export default class StatusPageResourceUptimeUtil {
         statusPageGroup: data.statusPageGroup,
         statusPageResources: data.statusPageResources,
         allStatusPageGroups: data.allStatusPageGroups,
+        statusPageGroupTreeIndex: data.statusPageGroupTreeIndex,
       });
 
     for (const resource of resourcesInGroup) {
@@ -187,6 +194,8 @@ export default class StatusPageResourceUptimeUtil {
      * makes each level of the hierarchy show a rolled up availability.
      */
     allStatusPageGroups?: Array<StatusPageGroup> | undefined;
+    /* See getCurrentStatusPageGroupStatus. */
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
   }): number | null {
     if (!data.statusPageGroup.showUptimePercent) {
       return null;
@@ -197,6 +206,7 @@ export default class StatusPageResourceUptimeUtil {
         statusPageGroup: data.statusPageGroup,
         statusPageResources: data.statusPageResources,
         allStatusPageGroups: data.allStatusPageGroups,
+        statusPageGroupTreeIndex: data.statusPageGroupTreeIndex,
       });
 
     if (resourcesInGroup.length === 0) {
@@ -276,11 +286,24 @@ export default class StatusPageResourceUptimeUtil {
     statusPageGroup: StatusPageGroup;
     statusPageResources: Array<StatusPageResource>;
     allStatusPageGroups?: Array<StatusPageGroup> | undefined;
+    /* See getCurrentStatusPageGroupStatus. */
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageResource> {
+    const statusPageGroups: Array<StatusPageGroup> =
+      data.allStatusPageGroups || [data.statusPageGroup];
+
     const groupsToInclude: Array<StatusPageGroup> =
       StatusPageGroupTreeUtil.getGroupAndDescendants({
         statusPageGroup: data.statusPageGroup,
-        statusPageGroups: data.allStatusPageGroups || [data.statusPageGroup],
+        statusPageGroups: statusPageGroups,
+        /*
+         * An index built over a different list than the one in play would
+         * answer for the wrong hierarchy, and allStatusPageGroups is what the
+         * caller's index is built from.
+         */
+        index: data.allStatusPageGroups
+          ? data.statusPageGroupTreeIndex
+          : undefined,
       });
 
     const groupIds: Set<string> = new Set<string>(
@@ -319,6 +342,15 @@ export default class StatusPageResourceUptimeUtil {
 
     const allUptimePercent: Array<number> = [];
 
+    /*
+     * One index for the whole descent below, rather than one re-bucketing of
+     * the group list per level and per reporting group.
+     */
+    const groupTreeIndex: StatusPageGroupTreeIndex =
+      StatusPageGroupTreeUtil.buildIndex({
+        statusPageGroups: data.resourceGroups,
+      });
+
     /*
      * Calculate for groups first. Groups nest, and a group that reports uptime
      * already averages its whole subtree - so descend only until the first
@@ -341,6 +373,7 @@ export default class StatusPageResourceUptimeUtil {
               monitorsInGroup: data.monitorsInGroup,
               uptimeWindow: data.uptimeWindow,
               allStatusPageGroups: data.resourceGroups,
+              statusPageGroupTreeIndex: groupTreeIndex,
             });
 
           if (groupUptimePercent !== null) {
@@ -354,6 +387,7 @@ export default class StatusPageResourceUptimeUtil {
           StatusPageGroupTreeUtil.getChildGroups({
             statusPageGroupId: group._id?.toString() || "",
             statusPageGroups: data.resourceGroups,
+            index: groupTreeIndex,
           }),
         );
       }
@@ -362,6 +396,7 @@ export default class StatusPageResourceUptimeUtil {
     collectGroupUptime(
       StatusPageGroupTreeUtil.getRootGroups({
         statusPageGroups: data.resourceGroups,
+        index: groupTreeIndex,
       }),
     );
 

package/Utils/Telemetry/SavedViewTimeRange.ts

@@ -0,0 +1,114 @@
+import InBetween from "../../Types/BaseDatabase/InBetween";
+import { TelemetrySavedViewTimeRange } from "../../Types/Telemetry/TelemetrySavedViewState";
+import RangeStartAndEndDateTime from "../../Types/Time/RangeStartAndEndDateTime";
+import TimeRange from "../../Types/Time/TimeRange";
+
+/*
+ * Saved views (logs, metrics, traces) must remember the time *selection*, not
+ * the window that selection happened to resolve to when the view was saved.
+ * "Past 1 Hour" saved today has to still mean the last hour next week, so only
+ * a Custom range carries absolute timestamps; every rolling range is stored as
+ * its token alone and re-resolved against the clock each time it is applied.
+ */
+
+export const DEFAULT_SAVED_VIEW_TIME_RANGE: TimeRange = TimeRange.PAST_ONE_HOUR;
+
+export function serializeSavedViewTimeRange(
+  timeRange: RangeStartAndEndDateTime,
+): TelemetrySavedViewTimeRange {
+  const serialized: TelemetrySavedViewTimeRange = { range: timeRange.range };
+
+  if (timeRange.range === TimeRange.CUSTOM && timeRange.startAndEndDate) {
+    serialized.startValue = toIsoString(timeRange.startAndEndDate.startValue);
+    serialized.endValue = toIsoString(timeRange.startAndEndDate.endValue);
+  }
+
+  return serialized;
+}
+
+/*
+ * Read a stored time selection, or undefined when there is nothing usable
+ * there. The input is whatever came back out of a JSON column, so nothing
+ * about its shape is guaranteed. Callers that have another source to fall
+ * back on (e.g. a legacy absolute window) use this; callers that do not use
+ * deserializeSavedViewTimeRange below, which substitutes the default.
+ */
+export function readSavedViewTimeRange(
+  saved: TelemetrySavedViewTimeRange | unknown,
+): RangeStartAndEndDateTime | undefined {
+  if (!saved || typeof saved !== "object") {
+    return undefined;
+  }
+
+  const rawRange: unknown = (saved as Record<string, unknown>)["range"];
+
+  if (typeof rawRange !== "string") {
+    return undefined;
+  }
+
+  const knownRanges: Array<string> = Object.values(TimeRange);
+
+  if (!knownRanges.includes(rawRange)) {
+    return undefined;
+  }
+
+  const range: TimeRange = rawRange as TimeRange;
+
+  if (range !== TimeRange.CUSTOM) {
+    return { range: range };
+  }
+
+  const start: Date | null = toDate(
+    (saved as Record<string, unknown>)["startValue"],
+  );
+  const end: Date | null = toDate(
+    (saved as Record<string, unknown>)["endValue"],
+  );
+
+  if (!start || !end) {
+    // A Custom range without a usable window says nothing about when to look.
+    return undefined;
+  }
+
+  return {
+    range: TimeRange.CUSTOM,
+    startAndEndDate: new InBetween<Date>(start, end),
+  };
+}
+
+/*
+ * Rebuild a RangeStartAndEndDateTime from saved state. Unknown or malformed
+ * values fall back to the default (past one hour) rather than throwing or
+ * producing a nonsensical window.
+ */
+export function deserializeSavedViewTimeRange(
+  saved: TelemetrySavedViewTimeRange | unknown,
+): RangeStartAndEndDateTime {
+  return (
+    readSavedViewTimeRange(saved) || { range: DEFAULT_SAVED_VIEW_TIME_RANGE }
+  );
+}
+
+function toIsoString(value: Date | string): string {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  // Dates round-tripped through JSON come back as strings.
+  const parsed: Date = new Date(value);
+  return isNaN(parsed.getTime()) ? String(value) : parsed.toISOString();
+}
+
+function toDate(value: unknown): Date | null {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? null : value;
+  }
+
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+
+  const parsed: Date = new Date(value);
+
+  return isNaN(parsed.getTime()) ? null : parsed;
+}

package/Utils/Telemetry/TelemetryQueryTimeRange.ts

@@ -0,0 +1,334 @@
+import InBetween from "../../Types/BaseDatabase/InBetween";
+import Query from "../../Types/BaseDatabase/Query";
+import { JSONObject, ObjectType } from "../../Types/JSON";
+import MetricViewData from "../../Types/Metrics/MetricViewData";
+import { TelemetryQuery } from "../../Types/Telemetry/TelemetryQuery";
+import TelemetryType from "../../Types/Telemetry/TelemetryType";
+import RangeStartAndEndDateTime from "../../Types/Time/RangeStartAndEndDateTime";
+import TimeRange from "../../Types/Time/TimeRange";
+
+/*
+ * The snapshot window that a telemetry monitor evaluated over is stamped onto
+ * the query it stores on the Incident / Alert row: logs and exceptions carry
+ * it as `time`, spans as `startTime`, metrics as `metricViewData.startAndEndDate`.
+ *
+ * Two things make that window awkward to consume on the client.
+ *
+ * 1. It does not survive the store/load round trip as Dates. The blob is
+ *    persisted through `JSON.stringify`, which calls `InBetween.toJSON()` and
+ *    then flattens each bound to an ISO string. On the way back
+ *    `InBetween.fromJSON()` reconstructs the operator but hands those strings
+ *    to the constructor untouched, so `startValue` is a `string` even though
+ *    the static type says `Date`. Anything guarding on `instanceof Date`
+ *    silently no-ops on an incident page.
+ *
+ * 2. Viewers that own a time-range picker (the logs viewer) need the window as
+ *    a `RangeStartAndEndDateTime`, not as a query filter, because the picker
+ *    state — not the query — is what drives the histogram and facet requests.
+ *
+ * These helpers are the single place that knows both shapes. They are pure so
+ * they can be unit tested without mounting a viewer.
+ */
+export default class TelemetryQueryTimeRange {
+  /*
+   * Field on the telemetry query that carries the snapshot window, per type.
+   * Metrics keep theirs on metricViewData instead, and profiles do not store a
+   * query at all, so both return null.
+   */
+  public static getWindowFieldName(
+    telemetryType: TelemetryType | undefined | null,
+  ): string | null {
+    if (telemetryType === TelemetryType.Log) {
+      return "time";
+    }
+
+    if (telemetryType === TelemetryType.Exception) {
+      return "time";
+    }
+
+    if (telemetryType === TelemetryType.Trace) {
+      return "startTime";
+    }
+
+    return null;
+  }
+
+  /*
+   * Coerce a stored window into an InBetween whose bounds are real Dates.
+   *
+   * Accepts an `InBetween` instance (bounds may be Dates, ISO strings or epoch
+   * numbers, depending on whether the value was just built or came back from
+   * storage) and the plain `{ _type: "InBetween", startValue, endValue }`
+   * object that a caller sees when it skipped `JSONFunctions.deserialize`.
+   *
+   * Returns null for anything unparseable so callers can fall back to their own
+   * default. An inverted window (start after end) is returned as-is rather than
+   * rejected: it renders as a visibly odd range the user can see and report,
+   * which beats silently swapping back to a rolling default that shows
+   * unrelated data under an incident's heading.
+   */
+  public static toDateWindow(value: unknown): InBetween<Date> | null {
+    if (!value || typeof value !== "object") {
+      return null;
+    }
+
+    let rawStart: unknown = undefined;
+    let rawEnd: unknown = undefined;
+
+    if (value instanceof InBetween) {
+      /*
+       * Already in the target shape — hand back the same instance rather than
+       * an equal copy. Callers use identity to decide whether anything changed,
+       * and a fresh-but-equal object would churn React state on every load.
+       */
+      if (
+        this.toDate(value.startValue) === value.startValue &&
+        this.toDate(value.endValue) === value.endValue
+      ) {
+        return value as InBetween<Date>;
+      }
+
+      rawStart = value.startValue;
+      rawEnd = value.endValue;
+    } else if ((value as JSONObject)["_type"] === ObjectType.InBetween) {
+      rawStart = (value as JSONObject)["startValue"];
+      rawEnd = (value as JSONObject)["endValue"];
+    } else {
+      return null;
+    }
+
+    const startDate: Date | null = this.toDate(rawStart);
+    const endDate: Date | null = this.toDate(rawEnd);
+
+    if (!startDate || !endDate) {
+      return null;
+    }
+
+    return new InBetween<Date>(startDate, endDate);
+  }
+
+  private static toDate(value: unknown): Date | null {
+    if (value === null || value === undefined) {
+      return null;
+    }
+
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? null : value;
+    }
+
+    if (typeof value !== "string" && typeof value !== "number") {
+      return null;
+    }
+
+    /*
+     * `new Date("")` is the current time, not an Invalid Date, so an empty
+     * bound would silently become "now" and quietly widen the window instead
+     * of being reported as missing.
+     */
+    if (typeof value === "string" && value.trim() === "") {
+      return null;
+    }
+
+    const parsed: Date = new Date(value);
+
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+
+  /*
+   * Pull the snapshot window out of a telemetry query record, whatever its
+   * telemetry type. Returns null when the monitor stored no window (older
+   * incidents, or a log monitor configured with no lastXSecondsOfLogs).
+   */
+  public static getSnapshotWindow(
+    telemetryQuery: TelemetryQuery | null | undefined,
+  ): InBetween<Date> | null {
+    if (!telemetryQuery) {
+      return null;
+    }
+
+    if (telemetryQuery.metricViewData) {
+      const metricWindow: InBetween<Date> | null = this.toDateWindow(
+        telemetryQuery.metricViewData.startAndEndDate,
+      );
+
+      if (metricWindow) {
+        return metricWindow;
+      }
+    }
+
+    return this.getQueryWindow(
+      telemetryQuery.telemetryQuery,
+      telemetryQuery.telemetryType,
+    );
+  }
+
+  /*
+   * Same, for a bare query. `telemetryType` picks the field to read; when it is
+   * unknown both known field names are tried so a caller holding only a query
+   * (e.g. the logs viewer, which is handed a Query<Log> and nothing else) still
+   * finds the window.
+   */
+  public static getQueryWindow(
+    query: Query<Record<string, unknown>> | JSONObject | null | undefined,
+    telemetryType?: TelemetryType | undefined,
+  ): InBetween<Date> | null {
+    if (!query) {
+      return null;
+    }
+
+    const fieldName: string | null = this.getWindowFieldName(telemetryType);
+    const fieldNames: Array<string> = fieldName
+      ? [fieldName]
+      : ["time", "startTime"];
+
+    for (const candidate of fieldNames) {
+      const window: InBetween<Date> | null = this.toDateWindow(
+        (query as JSONObject)[candidate],
+      );
+
+      if (window) {
+        return window;
+      }
+    }
+
+    return null;
+  }
+
+  /*
+   * Present a snapshot window as a picker value. Always CUSTOM: the window is
+   * an absolute instant in the past, so it must never re-anchor to "now" the
+   * way a relative range like "Past 1 Hour" does.
+   */
+  public static toRangeStartAndEndDateTime(
+    window: InBetween<Date> | null | undefined,
+  ): RangeStartAndEndDateTime | null {
+    if (!window) {
+      return null;
+    }
+
+    return {
+      range: TimeRange.CUSTOM,
+      startAndEndDate: window,
+    };
+  }
+
+  /*
+   * Convenience for viewers: resolve the pinned picker value for a query, or
+   * null when the query carries no window and the viewer should keep its own
+   * rolling default.
+   */
+  public static getPinnedRangeForQuery(
+    query: Query<Record<string, unknown>> | JSONObject | null | undefined,
+    telemetryType?: TelemetryType | undefined,
+  ): RangeStartAndEndDateTime | null {
+    return this.toRangeStartAndEndDateTime(
+      this.getQueryWindow(query, telemetryType),
+    );
+  }
+
+  /*
+   * Value equality for two picker values. Hosts that rebuild their query on
+   * every render produce an equal-but-new window each time, so state updates
+   * have to be gated on the value rather than on object identity or a
+   * re-render loop follows.
+   */
+  public static isSameRange(
+    a: RangeStartAndEndDateTime | null | undefined,
+    b: RangeStartAndEndDateTime | null | undefined,
+  ): boolean {
+    if (!a || !b) {
+      return !a && !b;
+    }
+
+    if (a.range !== b.range) {
+      return false;
+    }
+
+    const aWindow: InBetween<Date> | null = this.toDateWindow(
+      a.startAndEndDate,
+    );
+    const bWindow: InBetween<Date> | null = this.toDateWindow(
+      b.startAndEndDate,
+    );
+
+    if (!aWindow || !bWindow) {
+      return !aWindow && !bWindow;
+    }
+
+    return (
+      aWindow.startValue.getTime() === bWindow.startValue.getTime() &&
+      aWindow.endValue.getTime() === bWindow.endValue.getTime()
+    );
+  }
+
+  /*
+   * Rewrite a stored telemetry query so every window bound is a real Date.
+   *
+   * Consumers downstream gate real behaviour on `instanceof Date` — the metric
+   * chart skips aggregation-bucket alignment and never fetches exemplars when
+   * the bounds are strings — so hydrating once at the page's deserialize
+   * boundary is what makes those paths work on an incident.
+   *
+   * Returns the input unchanged (same reference) when there is nothing to fix,
+   * so callers can hydrate unconditionally without churning React state.
+   */
+  public static hydrate(
+    telemetryQuery: TelemetryQuery | null | undefined,
+  ): TelemetryQuery | null {
+    if (!telemetryQuery) {
+      return null;
+    }
+
+    let didChange: boolean = false;
+
+    let metricViewData: MetricViewData | null =
+      telemetryQuery.metricViewData || null;
+
+    if (metricViewData) {
+      const metricWindow: InBetween<Date> | null = this.toDateWindow(
+        metricViewData.startAndEndDate,
+      );
+
+      if (metricWindow && metricWindow !== metricViewData.startAndEndDate) {
+        metricViewData = {
+          ...metricViewData,
+          startAndEndDate: metricWindow,
+        };
+        didChange = true;
+      }
+    }
+
+    let query: TelemetryQuery["telemetryQuery"] =
+      telemetryQuery.telemetryQuery || null;
+
+    if (query) {
+      const fieldName: string | null = this.getWindowFieldName(
+        telemetryQuery.telemetryType,
+      );
+
+      if (fieldName) {
+        const window: InBetween<Date> | null = this.toDateWindow(
+          (query as JSONObject)[fieldName],
+        );
+
+        if (window && window !== (query as JSONObject)[fieldName]) {
+          query = {
+            ...(query as JSONObject),
+            [fieldName]: window,
+          } as TelemetryQuery["telemetryQuery"];
+          didChange = true;
+        }
+      }
+    }
+
+    if (!didChange) {
+      return telemetryQuery;
+    }
+
+    return {
+      ...telemetryQuery,
+      telemetryQuery: query,
+      metricViewData: metricViewData,
+    };
+  }
+}

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

@@ -30,6 +30,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import EnableDocumentation from "../../Types/Database/EnableDocumentation";
 import AIRunType from "../../Types/AI/AIRunType";
 import AIRunStatus from "../../Types/AI/AIRunStatus";
+import AIRunCodeFixRecommendation from "../../Types/AI/AIRunCodeFixRecommendation";
 import AIRunHumanVerdict from "../../Types/AI/AIRunHumanVerdict";
 import AIRunAutoGrade from "../../Types/AI/AIRunAutoGrade";
 import CodeFixTaskType from "../../Types/AI/CodeFixTaskType";
@@ -57,6 +58,15 @@ let AIRun = class AIRun extends BaseModel {
          */
         this.taskNumber = undefined;
         this.status = undefined;
+        /*
+         * The server-authored decision that controls whether an incident/alert
+         * investigation may be turned into a FixFromIncident task. New subject
+         * investigations move to Pending in the atomic Completed transition; the
+         * investigation engine settles the value after its structured
+         * classification and analysis post. Other lifecycle paths and legacy rows
+         * default to NotRecommended so a missing decision never creates a PR.
+         */
+        this.codeFixRecommendation = undefined;
         this.user = undefined;
         this.userId = undefined;
         this.conversation = undefined;
@@ -294,6 +304,34 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], AIRun.prototype, "status", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.Viewer,
+        ],
+        update: [],
+    }),
+    TableColumn({
+        required: true,
+        type: TableColumnType.ShortText,
+        title: "Code Fix Recommendation",
+        description: "For incident/alert investigations: whether the structured investigation outcome recommends opening a code-fix pull request.",
+        defaultValue: AIRunCodeFixRecommendation.NotRecommended,
+        isDefaultValueColumn: true,
+        canReadOnRelationQuery: true,
+    }),
+    Column({
+        nullable: false,
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+        default: AIRunCodeFixRecommendation.NotRecommended,
+    }),
+    __metadata("design:type", String)
+], AIRun.prototype, "codeFixRecommendation", void 0);
 __decorate([
     ColumnAccessControl({
         create: [],
@@ -832,7 +870,7 @@ __decorate([
         required: false,
         type: TableColumnType.JSON,
         title: "Task Context",
-        description: "Internal: trigger-time context for code-fix recipes without a subject row (e.g. FixPerformance trace evidence).",
+        description: "Internal: immutable trigger-time context for code-fix recipes, including pinned investigation analyses and FixPerformance trace evidence.",
     }),
     Column({
         nullable: true,