@oneuptime/common 12.0.28 → 12.0.30

package/Types/OnCallDutyPolicy/ScheduleShiftUtil.ts

@@ -1,5 +1,7 @@
 import CalendarEvent from "../Calendar/CalendarEvent";
 import OneUptimeDate from "../Date";
+import { ROTATION_PERIOD_START_KEY } from "./Layer";
+import UserOverrideUtil, { OverrideEventMeta } from "./UserOverrideUtil";
 
 /*
  * Turns the low-level calendar events produced by LayerUtil into the
@@ -36,6 +38,38 @@ export interface OnCallShift {
    * coverage ("40h across the week") instead of the misleading span ("4d 8h").
    */
   coverageSeconds: number;
+  /*
+   * Metadata carried over from the FIRST raw segment folded into this shift:
+   * the override that produced it (UserOverrideUtil stamps it on the event)
+   * and the layer it came from (LayerUtil stamps layerId/layerName when the
+   * caller identified the layer). Only present when the segment carried them.
+   *
+   * With the default grouping (by user id) a shift can span segments from
+   * several layers or override windows, so these describe the first segment
+   * only. Callers that need them to hold for the WHOLE shift pass a groupKey
+   * that includes them (see groupKeyByUserOverrideAndLayer), which is what the
+   * on-call calendar feed does.
+   */
+  override?: OverrideEventMeta;
+  layerId?: string;
+  layerName?: string;
+}
+
+/*
+ * Decides which raw segments may be folded into the same shift. Two adjacent
+ * segments are merged only when their keys are equal (and they touch, or the
+ * caller asked to merge across gaps).
+ */
+export type ShiftGroupKeyFunction = (event: CalendarEvent) => string;
+
+export interface GroupEventsIntoShiftsOptions {
+  mergeAcrossGaps?: boolean | undefined;
+  /*
+   * Defaults to the on-call user id (event.title), which is what every
+   * schedule summary in the dashboard wants: "Alice, Mon 09:00 -> Fri 17:00"
+   * regardless of which layer or override put her there.
+   */
+  groupKey?: ShiftGroupKeyFunction | undefined;
 }
 
 export interface CoverageGap {
@@ -116,13 +150,15 @@ export default class ScheduleShiftUtil {
    */
   public static groupEventsIntoShifts(
     events: Array<CalendarEvent>,
-    options?: { mergeAcrossGaps?: boolean | undefined } | undefined,
+    options?: GroupEventsIntoShiftsOptions | undefined,
   ): Array<OnCallShift> {
     if (!events || events.length === 0) {
       return [];
     }
 
     const mergeAcrossGaps: boolean = Boolean(options?.mergeAcrossGaps);
+    const groupKey: ShiftGroupKeyFunction =
+      options?.groupKey ?? ScheduleShiftUtil.defaultGroupKey;
 
     // Work on a copy sorted by start time; never mutate the caller's array.
     const sorted: Array<CalendarEvent> = [...events]
@@ -142,16 +178,18 @@ export default class ScheduleShiftUtil {
       });
 
     const shifts: Array<OnCallShift> = [];
+    let lastKey: string | null = null;
 
     for (const event of sorted) {
       const userId: string = event.title;
+      const key: string = groupKey(event);
       const eventSeconds: number = OneUptimeDate.getDifferenceInSeconds(
         event.end,
         event.start,
       );
       const last: OnCallShift | undefined = shifts[shifts.length - 1];
 
-      const sameUser: boolean = Boolean(last) && last!.userId === userId;
+      const sameUser: boolean = Boolean(last) && lastKey === key;
 
       const isContiguous: boolean =
         Boolean(last) &&
@@ -175,17 +213,134 @@ export default class ScheduleShiftUtil {
         continue;
       }
 
-      shifts.push({
+      const shift: OnCallShift = {
         userId,
         start: event.start,
         end: event.end,
         coverageSeconds: eventSeconds,
-      });
+      };
+
+      /*
+       * Only add the metadata keys when the segment carries them, so callers
+       * that never stamp them (every dashboard summary) get the exact shift
+       * objects they always did.
+       */
+      const override: OverrideEventMeta | null =
+        UserOverrideUtil.getOverrideMeta(event);
+      if (override) {
+        shift.override = override;
+      }
+
+      const layerId: string | undefined =
+        ScheduleShiftUtil.getEventLayerId(event);
+      if (layerId !== undefined) {
+        shift.layerId = layerId;
+      }
+
+      const layerName: string | undefined =
+        ScheduleShiftUtil.getEventLayerName(event);
+      if (layerName !== undefined) {
+        shift.layerName = layerName;
+      }
+
+      shifts.push(shift);
+      lastKey = key;
     }
 
     return shifts;
   }
 
+  // The default grouping: one shift per run of the same on-call user.
+  public static defaultGroupKey(event: CalendarEvent): string {
+    return event.title;
+  }
+
+  /*
+   * Grouping that keeps a shift inside ONE layer, ONE override window and ONE
+   * rotation period: the user id, plus the override identity (original user +
+   * window) when the segment was produced by an override, plus the layer id
+   * when known, plus the rotation period the engine stamped on the event. This
+   * is the key the on-call calendar feed groups with, so an override split
+   * yields A / B / A as three events and a layer handover is visible as a
+   * boundary instead of being folded into a single shift.
+   *
+   * The rotation period matters because two consecutive turns held by the SAME
+   * user (a single-user layer, or [A, A, B]) are contiguous across the engine's
+   * 1 s seam and would otherwise fold into one block whose start and end are
+   * decided by how far the expansion window reached — the block would slide
+   * forward every time the feed window did, changing the event's UID and
+   * DTSTART for every subscriber. Override segments deliberately ignore the
+   * period: an override that spans a rotation boundary is ONE stretch of cover
+   * and stays one event.
+   */
+  public static groupKeyByUserOverrideAndLayer(event: CalendarEvent): string {
+    const override: OverrideEventMeta | null =
+      UserOverrideUtil.getOverrideMeta(event);
+
+    const overridePart: string = override
+      ? `${override.originalUserId}@${override.overrideStartsAt.getTime()}-${override.overrideEndsAt.getTime()}`
+      : "";
+
+    const periodStart: number | undefined = override
+      ? undefined
+      : ScheduleShiftUtil.getEventRotationPeriodStart(event);
+
+    const periodPart: string =
+      periodStart === undefined ? "" : periodStart.toString();
+
+    return `${event.title}|${overridePart}|${ScheduleShiftUtil.getEventLayerId(event) ?? ""}|${periodPart}`;
+  }
+
+  /*
+   * LayerUtil stamps layerId/layerName onto merged events (see
+   * PriorityCalendarEvents). CalendarEvent is a JSONObject, so the keys are
+   * read through the index signature and type-checked here.
+   */
+  public static getEventLayerId(event: CalendarEvent): string | undefined {
+    const value: unknown = (event as unknown as Record<string, unknown>)[
+      "layerId"
+    ];
+    return typeof value === "string" ? value : undefined;
+  }
+
+  public static getEventLayerName(event: CalendarEvent): string | undefined {
+    const value: unknown = (event as unknown as Record<string, unknown>)[
+      "layerName"
+    ];
+    return typeof value === "string" ? value : undefined;
+  }
+
+  /*
+   * Epoch milliseconds of the rotation period an engine event belongs to (see
+   * ROTATION_PERIOD_START_KEY in Layer.ts). Undefined for hand-built events and
+   * for anything that did not come out of LayerUtil — those simply group as
+   * they always did. Dates and ISO strings are accepted so a JSON round trip
+   * does not silently drop the period.
+   */
+  public static getEventRotationPeriodStart(
+    event: CalendarEvent,
+  ): number | undefined {
+    const value: unknown = (event as unknown as Record<string, unknown>)[
+      ROTATION_PERIOD_START_KEY
+    ];
+
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : undefined;
+    }
+
+    if (value instanceof Date) {
+      const time: number = value.getTime();
+      return Number.isNaN(time) ? undefined : time;
+    }
+
+    if (typeof value === "string") {
+      const parsed: number = Date.parse(value);
+      return Number.isNaN(parsed) ? undefined : parsed;
+    }
+
+    return undefined;
+  }
+
   /*
    * The shift that contains `now` (the person on call right now) and the first
    * shift that starts after `now` (up next). Either can be null: `current` is

package/Types/OnCallDutyPolicy/ShiftSeamUtil.ts

@@ -0,0 +1,106 @@
+/*
+ * Seam normalisation for resolved on-call segments.
+ *
+ * The rotation engine and its post-processors leave one-second artefacts at
+ * every boundary: LayerUtil resumes each segment one second after the
+ * previous one ends (Layer.ts advances with addRemoveSeconds(end, 1)), the
+ * multi-layer priority merge trims to `start - 1s` / `end + 1s`, and the
+ * override splitter cuts at the exact instant. Fed straight into a calendar
+ * that renders as 09:00:01 -> 16:59:59, with adjacent shifts that neither
+ * touch nor overlap — which Google's week view draws side by side.
+ *
+ * Handoff and restriction times are minute-granular by construction, so the
+ * artefacts are unambiguous: a start on second 1 means the minute, an end on
+ * second 59 means the next minute, and two segments a second apart are
+ * meant to touch. Everything else is left alone.
+ */
+
+export interface TimeSegment {
+  start: Date;
+  end: Date;
+}
+
+// Segments this close together (in ms) are made to touch exactly.
+export const SEAM_TOLERANCE_MILLISECONDS: number = 1000;
+
+const MILLISECONDS_PER_MINUTE: number = 60 * 1000;
+
+export default class ShiftSeamUtil {
+  /*
+   * Returns a NEW array (sorted by start, then end) of NEW segment objects
+   * with the seams normalised; neither the input array nor its segments are
+   * mutated. Any extra properties on the segments are preserved, so this can
+   * run on OnCallShift / MaterializedShift objects directly.
+   *
+   * Rules, in order:
+   *  1. a start whose seconds == 1 snaps DOWN to the minute;
+   *  2. an end whose seconds == 59 snaps UP to the next minute;
+   *  3. walking in start order, when the next segment starts 0..1 s after
+   *     this one ends, this one's end becomes exactly the next one's start.
+   * Snapping only ever widens a segment, so it cannot create an empty or
+   * inverted one; a segment that is already empty or inverted is left alone.
+   */
+  public static normalizeSeams<T extends TimeSegment>(
+    segments: Array<T>,
+  ): Array<T> {
+    const normalized: Array<T> = segments.map((segment: T) => {
+      const snappedStart: Date = ShiftSeamUtil.snapStart(segment.start);
+      const snappedEnd: Date = ShiftSeamUtil.snapEnd(segment.end);
+
+      const keepSnaps: boolean =
+        segment.end.getTime() > segment.start.getTime() &&
+        snappedEnd.getTime() > snappedStart.getTime();
+
+      return {
+        ...segment,
+        start: keepSnaps ? snappedStart : new Date(segment.start.getTime()),
+        end: keepSnaps ? snappedEnd : new Date(segment.end.getTime()),
+      };
+    });
+
+    normalized.sort((a: T, b: T) => {
+      const byStart: number = a.start.getTime() - b.start.getTime();
+      if (byStart !== 0) {
+        return byStart;
+      }
+      return a.end.getTime() - b.end.getTime();
+    });
+
+    for (let i: number = 0; i < normalized.length - 1; i++) {
+      const segment: T = normalized[i]!;
+      const next: T = normalized[i + 1]!;
+
+      const delta: number = next.start.getTime() - segment.end.getTime();
+
+      if (delta >= 0 && delta <= SEAM_TOLERANCE_MILLISECONDS) {
+        segment.end = new Date(next.start.getTime());
+      }
+    }
+
+    return normalized;
+  }
+
+  // 10:00:01(.xxx) -> 10:00:00.000; anything else is returned as a copy.
+  public static snapStart(date: Date): Date {
+    if (date.getUTCSeconds() === 1) {
+      return new Date(
+        Math.floor(date.getTime() / MILLISECONDS_PER_MINUTE) *
+          MILLISECONDS_PER_MINUTE,
+      );
+    }
+
+    return new Date(date.getTime());
+  }
+
+  // 16:59:59(.xxx) -> 17:00:00.000; anything else is returned as a copy.
+  public static snapEnd(date: Date): Date {
+    if (date.getUTCSeconds() === 59) {
+      return new Date(
+        (Math.floor(date.getTime() / MILLISECONDS_PER_MINUTE) + 1) *
+          MILLISECONDS_PER_MINUTE,
+      );
+    }
+
+    return new Date(date.getTime());
+  }
+}

package/Types/Rum/SessionReplay.ts

@@ -327,10 +327,52 @@ export interface SessionReplayChunkEnvelope {
   traceIds?: Array<string>;
 }
 
+/*
+ * WHY a config response says enabled:false.
+ *
+ * The disabled response is deliberately a complete, well-formed config
+ * rather than an error, so a recorder that cannot parse a config still
+ * refuses to record. The cost of that was one answer for five very
+ * different causes: from a browser, an instance-wide kill switch, a
+ * deployment whose recorder bundle was never built, an application
+ * somebody switched off and a Redis outage were all "enabled: false" and
+ * nothing else, and no amount of dashboard configuration fixes three of
+ * them.
+ *
+ * This is a closed vocabulary carrying no project data - it is answered
+ * only to a request already bearing a valid ingestion key for that
+ * project, and it says strictly less than the Dashboard's own ingest
+ * status endpoint already shows the same customer.
+ */
+export enum SessionReplayDisabledReason {
+  /* SESSION_REPLAY_INGEST_ENABLED=false on this deployment. */
+  IngestDisabled = "ingest-disabled",
+
+  /* SESSION_REPLAY_ENABLED_BY_DEFAULT=false on this deployment. */
+  DisabledByDefault = "disabled-by-default",
+
+  /*
+   * No published recorder artifact. The build never ran, or its output is
+   * not where the server looks for it - overwhelmingly the answer on a
+   * self-hosted install where replay has never worked at all.
+   */
+  RecorderNotBuilt = "recorder-not-built",
+
+  /* The policy lookup threw. Fail closed, and say that it failed. */
+  PolicyUnavailable = "policy-unavailable",
+
+  /*
+   * No policy for this project/application pair: the application is
+   * switched off, the project is not allowed replay, the identifier does
+   * not match one, or a kill key is set.
+   */
+  NotEnabledForApplication = "not-enabled-for-application",
+}
+
 /*
  * Policy snapshot handed to the recorder at startup. This endpoint is
  * what makes every server-side privacy control reachable by a live
- * recorder — without it, flipping a masking setting would never take
+ * recorder - without it, flipping a masking setting would never take
  * effect in a browser that already loaded.
  */
 export interface SessionReplayConfigResponse {
@@ -415,6 +457,25 @@ export interface SessionReplayConfigResponse {
   configEpoch: number;
 
   directive: SessionReplayDirective;
+
+  /*
+   * Set only alongside enabled:false. Optional on the wire like every
+   * other field added after v1: an older recorder ignores it, a newer one
+   * logs it, and neither breaks.
+   */
+  disabledReason?: SessionReplayDisabledReason;
+
+  /*
+   * Ask every recorder that reads this policy to print its decisions to
+   * the browser console (SESSION_REPLAY_DEBUG on the deployment).
+   *
+   * The switch of last resort, and the only one an operator can reach
+   * without editing a page they do not own: the per-browser localStorage
+   * and query-string switches need somebody at that browser. It is off by
+   * default and must stay that way - a RUM script logging on every visitor
+   * of every customer is noise on somebody else's site.
+   */
+  debug?: boolean;
 }
 
 /* Response to a chunk POST. Deliberately tiny. */

package/UI/Components/Date/TimeRangePickerDropdown.tsx

@@ -7,6 +7,7 @@ import React, {
   useState,
 } from "react";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
+import OneUptimeDate from "../../../Types/Date";
 import IconProp from "../../../Types/Icon/IconProp";
 import RangeStartAndEndDateTime, {
   RangeStartAndEndDateTimeUtil,
@@ -54,12 +55,15 @@ export const TIME_RANGE_PRESET_OPTIONS: Array<TimeRangePickerPresetOption> = [
   { range: TimeRange.PAST_THREE_MONTHS, label: "Past 3 Months" },
 ];
 
+/*
+ * Both ends of a custom window are written the way the user's machine writes
+ * times: on its 12- or 24-hour clock, in the timezone they configured. Reading
+ * the digits off the Date itself - which is what this used to do - pinned the
+ * label to a 24-hour clock in whatever zone the browser process happened to be
+ * in, so a machine set to AM/PM still got "Mar 1, 14:30" back.
+ */
 function formatDateShort(date: Date): string {
-  const month: string = date.toLocaleString("en-US", { month: "short" });
-  const day: number = date.getDate();
-  const hours: string = date.getHours().toString().padStart(2, "0");
-  const minutes: string = date.getMinutes().toString().padStart(2, "0");
-  return `${month} ${day}, ${hours}:${minutes}`;
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date);
 }
 
 export function getTimeRangeButtonLabel(

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -175,7 +175,11 @@ const severityWeight: Record<string, number> = {
   trace: 1,
 };
 
-function getEmptyMessageWithTimeRange(
+/*
+ * Exported so the window it reports can be unit-tested directly - rendering the
+ * whole viewer to read one sentence is not worth the setup.
+ */
+export function getEmptyMessageWithTimeRange(
   timeRange: RangeStartAndEndDateTime | undefined,
 ): string {
   if (!timeRange) {
@@ -185,13 +189,14 @@ function getEmptyMessageWithTimeRange(
   if (timeRange.range === TimeRange.CUSTOM && timeRange.startAndEndDate) {
     const startDate: Date = timeRange.startAndEndDate.startValue;
     const endDate: Date = timeRange.startAndEndDate.endValue;
+    /*
+     * Same shape, clock and timezone as the label on the picker button that
+     * set this window - pinning en-US here handed a US viewer AM/PM even on a
+     * 24-hour machine, and read the digits in the browser's zone rather than
+     * the one configured in User Settings.
+     */
     const fmt: (d: Date) => string = (d: Date): string => {
-      return d.toLocaleString("en-US", {
-        month: "short",
-        day: "numeric",
-        hour: "2-digit",
-        minute: "2-digit",
-      });
+      return OneUptimeDate.getDateAsLocalShortDateTimeString(d);
     };
 
     return `Time range: ${fmt(startDate)} – ${fmt(endDate)}. Try adjusting filters or expanding the time range.`;

package/UI/Components/LogsViewer/components/HistogramTooltip.tsx

@@ -28,26 +28,27 @@ function formatTooltipTime(label: string | undefined): string {
     return label;
   }
 
-  const now: Date = new Date();
-  const isToday: boolean = date.toDateString() === now.toDateString();
-
-  const time: string = date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-  });
-
-  if (isToday) {
-    return time;
+  const use12HourFormat: boolean = OneUptimeDate.getUserPrefers12HourFormat();
+
+  /*
+   * Today's buckets need no date on them - the explorer's own range picker
+   * already says which day is on screen. "Today" has to be decided in the
+   * configured timezone, or buckets either side of midnight there get the
+   * date added and dropped a few hours off.
+   */
+  if (
+    OneUptimeDate.areOnTheSameLocalDay(date, OneUptimeDate.getCurrentDate())
+  ) {
+    return OneUptimeDate.getLocalTimeString(date, {
+      includeSeconds: true,
+      use12HourFormat,
+    });
   }
 
-  const dateStr: string = date.toLocaleDateString([], {
-    month: "short",
-    day: "numeric",
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date, {
+    includeSeconds: true,
+    use12HourFormat,
   });
-
-  return `${dateStr}, ${time}`;
 }
 
 const HistogramTooltip: FunctionComponent<HistogramTooltipProps> = (

package/UI/Components/LogsViewer/components/LogsAnalyticsView.tsx

@@ -134,17 +134,32 @@ function pivotTimeseriesData(rows: Array<AnalyticsTimeseriesRow>): {
   };
 }
 
-function formatTickTime(time: string): string {
+export function formatTickTime(time: string): string {
   const date: Date = OneUptimeDate.fromString(time);
 
   if (isNaN(date.getTime())) {
     return time;
   }
 
-  return date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
+  return OneUptimeDate.getLocalTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
+  });
+}
+
+/** The bucket a tooltip is pointing at, dated because it can be any day in the window. */
+export function formatTooltipLabel(label: string | undefined): string {
+  if (!label) {
+    return "";
+  }
+
+  const date: Date = OneUptimeDate.fromString(label);
+
+  if (isNaN(date.getTime())) {
+    return label;
+  }
+
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
   });
 }
 
@@ -234,32 +249,10 @@ const AnalyticsTooltip: FunctionComponent<AnalyticsTooltipProps> = (
     0,
   );
 
-  const formatTime: (label: string | undefined) => string = (
-    label: string | undefined,
-  ): string => {
-    if (!label) {
-      return "";
-    }
-
-    const date: Date = OneUptimeDate.fromString(label);
-
-    if (isNaN(date.getTime())) {
-      return label;
-    }
-
-    return date.toLocaleString([], {
-      month: "short",
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-      hour12: false,
-    });
-  };
-
   return (
     <div className="rounded-lg border border-gray-200/80 bg-white/95 px-3.5 py-2.5 shadow-lg backdrop-blur-sm">
       <p className="mb-2 border-b border-gray-100 pb-2 font-mono text-[11px] font-medium text-gray-400">
-        {formatTime(props.label)}
+        {formatTooltipLabel(props.label)}
       </p>
       <div className="space-y-1">
         {entries.map((entry: { key: string; value: number; color: string }) => {

package/UI/Components/LogsViewer/components/LogsHistogram.tsx

@@ -68,10 +68,8 @@ function formatTickTime(time: string): string {
     return time;
   }
 
-  return date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
+  return OneUptimeDate.getLocalTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
   });
 }
 

package/UI/Components/TelemetryViewer/components/TelemetryHistogram.tsx

@@ -73,10 +73,8 @@ function formatTickTime(time: string): string {
     return time;
   }
 
-  return date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
+  return OneUptimeDate.getLocalTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
   });
 }
 

package/UI/Components/TelemetryViewer/components/TelemetryHistogramTooltip.tsx

@@ -34,26 +34,27 @@ function formatTooltipTime(label: string | undefined): string {
     return label;
   }
 
-  const now: Date = new Date();
-  const isToday: boolean = date.toDateString() === now.toDateString();
+  const use12HourFormat: boolean = OneUptimeDate.getUserPrefers12HourFormat();
 
-  const time: string = date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-  });
-
-  if (isToday) {
-    return time;
+  /*
+   * Today's buckets need no date on them - the explorer's own range picker
+   * already says which day is on screen. "Today" has to be decided in the
+   * configured timezone, or buckets either side of midnight there get the
+   * date added and dropped a few hours off.
+   */
+  if (
+    OneUptimeDate.areOnTheSameLocalDay(date, OneUptimeDate.getCurrentDate())
+  ) {
+    return OneUptimeDate.getLocalTimeString(date, {
+      includeSeconds: true,
+      use12HourFormat,
+    });
   }
 
-  const dateStr: string = date.toLocaleDateString([], {
-    month: "short",
-    day: "numeric",
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date, {
+    includeSeconds: true,
+    use12HourFormat,
   });
-
-  return `${dateStr}, ${time}`;
 }
 
 const TelemetryHistogramTooltip: FunctionComponent<