@oneuptime/common 12.0.1 → 12.0.2

package/UI/Utils/TeamMembersByUser.ts

@@ -0,0 +1,302 @@
+import Team from "../../Models/DatabaseModels/Team";
+import TeamMember from "../../Models/DatabaseModels/TeamMember";
+
+/*
+ * TeamMember is a (user, team) pair, so a list of team members is a list of
+ * memberships - not a list of people. Rendering it straight into a "Users"
+ * table gives one row per membership, and someone who belongs to three teams
+ * reads as three separate people with the same name and avatar.
+ *
+ * These helpers collapse memberships into one row per person, carrying every
+ * team that person belongs to on the row so the table can show them together.
+ * The row is still a TeamMember (the table, its columns and its delete action
+ * are all typed against the model) - it just stands for the user rather than
+ * for one of their memberships.
+ */
+
+export interface ProjectUserExtras {
+  // Every team this user belongs to, sorted by name.
+  teamsForUser: Array<Team>;
+  teamCountForUser: number;
+  /*
+   * How many of those memberships are still unaccepted invitations. A user can
+   * be a fully accepted member of one team and a pending invite on another.
+   */
+  pendingTeamCountForUser: number;
+}
+
+export type ProjectUserRow = TeamMember & ProjectUserExtras;
+
+export default class TeamMembersByUser {
+  /**
+   * The identity a membership is grouped under. Null when the row carries no
+   * user at all - those rows are never merged, because merging them would put
+   * unrelated memberships on one line.
+   */
+  public static getGroupKey(teamMember: TeamMember): string | null {
+    const userId: string =
+      teamMember.userId?.toString() || teamMember.user?._id?.toString() || "";
+
+    return userId || null;
+  }
+
+  /**
+   * The name this row sorts and reads under. Falls back to the email so a user
+   * who was invited but has not set a name yet still lands somewhere sensible.
+   */
+  public static getDisplayName(teamMember: TeamMember): string {
+    return (
+      teamMember.user?.name?.toString() ||
+      teamMember.user?.email?.toString() ||
+      ""
+    );
+  }
+
+  /**
+   * One row per user, in the order each user was first seen. The input order is
+   * whatever the server sorted by, so first-seen order keeps that sort intact.
+   *
+   * The returned rows are the same TeamMember instances that came in (the first
+   * membership seen for each user), mutated with the aggregate fields.
+   */
+  public static groupByUser(
+    teamMembers: Array<TeamMember>,
+  ): Array<ProjectUserRow> {
+    const rowsByGroupKey: Map<string, ProjectUserRow> = new Map<
+      string,
+      ProjectUserRow
+    >();
+    const rows: Array<ProjectUserRow> = [];
+
+    /*
+     * Which teams are already on a row, keyed the same way for every
+     * membership. Tracked here rather than re-derived from `teamsForUser`
+     * because a membership identifies its team by `teamId` while the team
+     * object it carries identifies itself by `_id`, and either one can be
+     * missing from a given select.
+     */
+    const teamKeysByRow: Map<ProjectUserRow, Set<string>> = new Map<
+      ProjectUserRow,
+      Set<string>
+    >();
+
+    /*
+     * Every membership id folded into each row, so the row can be given a
+     * stable identity below.
+     */
+    const membershipIdsByRow: Map<ProjectUserRow, Array<string>> = new Map<
+      ProjectUserRow,
+      Array<string>
+    >();
+
+    for (const teamMember of teamMembers) {
+      const groupKey: string | null = this.getGroupKey(teamMember);
+
+      const existingRow: ProjectUserRow | undefined = groupKey
+        ? rowsByGroupKey.get(groupKey)
+        : undefined;
+
+      if (existingRow) {
+        this.addMembershipToRow(
+          existingRow,
+          teamMember,
+          teamKeysByRow.get(existingRow)!,
+          Boolean(teamMember.hasAcceptedInvitation),
+        );
+        this.rememberMembershipId(
+          membershipIdsByRow.get(existingRow)!,
+          teamMember,
+        );
+        continue;
+      }
+
+      const row: ProjectUserRow = teamMember as ProjectUserRow;
+      const teamKeys: Set<string> = new Set<string>();
+      const membershipIds: Array<string> = [];
+
+      /*
+       * The row *is* this membership, so read its acceptance before the reset
+       * below overwrites it.
+       */
+      const hasAcceptedInvitation: boolean = Boolean(
+        teamMember.hasAcceptedInvitation,
+      );
+
+      row.teamsForUser = [];
+      row.teamCountForUser = 0;
+      row.pendingTeamCountForUser = 0;
+
+      /*
+       * Reset before folding the row's own membership back in: on a grouped row
+       * this field means "is a member of this project", which is true as soon as
+       * any one of the memberships has been accepted.
+       */
+      row.hasAcceptedInvitation = false;
+
+      teamKeysByRow.set(row, teamKeys);
+      membershipIdsByRow.set(row, membershipIds);
+      this.addMembershipToRow(row, teamMember, teamKeys, hasAcceptedInvitation);
+      this.rememberMembershipId(membershipIds, teamMember);
+
+      if (groupKey) {
+        rowsByGroupKey.set(groupKey, row);
+      }
+
+      rows.push(row);
+    }
+
+    for (const row of rows) {
+      this.finalizeRow(row, membershipIdsByRow.get(row) || []);
+    }
+
+    return rows;
+  }
+
+  /**
+   * Replaces the team aggregate on each row with the one derived from
+   * `allTeamMembers`.
+   *
+   * Needed because the rows on screen may have been built from a *filtered*
+   * membership list - filter the table by one team and grouping only ever sees
+   * that team, so the Teams column would claim each user belongs to exactly the
+   * team that was filtered for. The caller re-reads the unfiltered memberships
+   * for the users on the current page and merges them back in here.
+   *
+   * Rows with no matching membership in `allTeamMembers` are left untouched.
+   */
+  public static mergeAllTeamsIntoRows(
+    rows: Array<ProjectUserRow>,
+    allTeamMembers: Array<TeamMember>,
+  ): Array<ProjectUserRow> {
+    const groupedRows: Array<ProjectUserRow> = this.groupByUser(allTeamMembers);
+
+    const groupedRowsByKey: Map<string, ProjectUserRow> = new Map<
+      string,
+      ProjectUserRow
+    >();
+
+    for (const groupedRow of groupedRows) {
+      const groupKey: string | null = this.getGroupKey(groupedRow);
+
+      if (groupKey) {
+        groupedRowsByKey.set(groupKey, groupedRow);
+      }
+    }
+
+    for (const row of rows) {
+      const groupKey: string | null = this.getGroupKey(row);
+      const groupedRow: ProjectUserRow | undefined = groupKey
+        ? groupedRowsByKey.get(groupKey)
+        : undefined;
+
+      if (!groupedRow) {
+        continue;
+      }
+
+      row.teamsForUser = groupedRow.teamsForUser;
+      row.teamCountForUser = groupedRow.teamCountForUser;
+      row.pendingTeamCountForUser = groupedRow.pendingTeamCountForUser;
+      row.hasAcceptedInvitation = Boolean(groupedRow.hasAcceptedInvitation);
+    }
+
+    return rows;
+  }
+
+  /**
+   * Alphabetical by display name, case-insensitively. Rows with no name at all
+   * sort last so the list does not open on a run of blanks.
+   *
+   * Returns a new array; the input is left alone.
+   */
+  public static sortRowsByUserName(
+    rows: Array<ProjectUserRow>,
+  ): Array<ProjectUserRow> {
+    return [...rows].sort((a: ProjectUserRow, b: ProjectUserRow) => {
+      const nameA: string = this.getDisplayName(a).toLowerCase();
+      const nameB: string = this.getDisplayName(b).toLowerCase();
+
+      if (!nameA && !nameB) {
+        return 0;
+      }
+
+      if (!nameA) {
+        return 1;
+      }
+
+      if (!nameB) {
+        return -1;
+      }
+
+      return nameA.localeCompare(nameB);
+    });
+  }
+
+  private static addMembershipToRow(
+    row: ProjectUserRow,
+    teamMember: TeamMember,
+    teamKeys: Set<string>,
+    hasAcceptedInvitation: boolean,
+  ): void {
+    if (hasAcceptedInvitation) {
+      row.hasAcceptedInvitation = true;
+    } else {
+      row.pendingTeamCountForUser = row.pendingTeamCountForUser + 1;
+    }
+
+    const team: Team | undefined = teamMember.team;
+
+    if (!team) {
+      return;
+    }
+
+    const teamKey: string =
+      teamMember.teamId?.toString() ||
+      team._id?.toString() ||
+      team.name?.toString() ||
+      "";
+
+    if (!teamKey || teamKeys.has(teamKey)) {
+      return;
+    }
+
+    teamKeys.add(teamKey);
+    row.teamsForUser.push(team);
+  }
+
+  private static rememberMembershipId(
+    membershipIds: Array<string>,
+    teamMember: TeamMember,
+  ): void {
+    const membershipId: string = teamMember._id?.toString() || "";
+
+    if (membershipId) {
+      membershipIds.push(membershipId);
+    }
+  }
+
+  private static finalizeRow(
+    row: ProjectUserRow,
+    membershipIds: Array<string>,
+  ): void {
+    row.teamsForUser.sort((a: Team, b: Team) => {
+      return (a.name?.toString() || "")
+        .toLowerCase()
+        .localeCompare((b.name?.toString() || "").toLowerCase());
+    });
+
+    row.teamCountForUser = row.teamsForUser.length;
+
+    /*
+     * The row's id has to identify the *person*, not "whichever of their
+     * memberships was returned first". The table matches a selected row to an
+     * on-screen row by _id, and it fetches the on-screen page and the
+     * select-all set with two different sorts - so a first-seen id makes the
+     * same person carry different ids in the two results, and every
+     * multi-team user's checkbox silently fails to tick. The lowest membership
+     * id is stable under any ordering the server returns.
+     */
+    if (membershipIds.length > 1) {
+      row._id = [...membershipIds].sort()[0]!;
+    }
+  }
+}

package/Utils/StatusPage/ReportPeriod.ts

@@ -0,0 +1,236 @@
+import OneUptimeDate, { CalendarUnit } from "../../Types/Date";
+import EventInterval from "../../Types/Events/EventInterval";
+import Recurring from "../../Types/Events/Recurring";
+import StatusPageReportPeriodType from "../../Types/StatusPage/StatusPageReportPeriodType";
+import Timezone from "../../Types/Timezone";
+
+/*
+ * The exact stretch of time one scheduled status page report covers, plus the
+ * strings the email and the settings screen use to describe it.
+ *
+ * Deliberately pure and synchronous, and deliberately in Common/Utils rather
+ * than Common/Server: the settings screen renders the very same window the
+ * worker will use, so what the user is shown before saving is what actually
+ * gets emailed. That is the whole point of the calendar option - a report is no
+ * longer "whatever the last 30 days happened to be when the cron fired".
+ */
+export interface StatusPageReportPeriod {
+  // Inclusive. The first instant the report measures.
+  startDate: Date;
+  // Inclusive. The last instant the report measures.
+  endDate: Date;
+  // Whole days spanned, kept for display and for callers that think in days.
+  numberOfDays: number;
+  // The zone every boundary above was resolved in.
+  timezone: Timezone;
+  /*
+   * The `report.reportDates` template variable. Rolling windows keep the exact
+   * shape they have always had ("30 days (Jun 29, 2026 - Jul 29, 2026)") so
+   * customer-authored email templates written against it keep reading the same;
+   * calendar windows, which are new, are just the range.
+   */
+  reportDates: string;
+  /*
+   * How a sentence refers to the period: "the last 30 days", "July 2026",
+   * "the week of Jul 27, 2026". Reads correctly after "your status summary
+   * for ...", which the old string did not once periods stopped being rolling.
+   */
+  periodName: string;
+}
+
+export default class StatusPageReportPeriodUtil {
+  public static readonly DEFAULT_REPORT_DATA_IN_DAYS: number = 30;
+  public static readonly DEFAULT_TIMEZONE: Timezone = Timezone.UTC;
+
+  public static getDefaultPeriodType(): StatusPageReportPeriodType {
+    return StatusPageReportPeriodType.Rolling;
+  }
+
+  /*
+   * Resolve the window a report sent at `sentAt` (default: now) covers.
+   *
+   * Everything is optional because this is called with a half-filled form as
+   * the user types, and with columns that are null on status pages created
+   * before reports were configurable. Missing values fall back to the same
+   * defaults the database columns carry.
+   */
+  public static getReportPeriod(data: {
+    periodType?: StatusPageReportPeriodType | undefined;
+    reportRecurringInterval?: Recurring | undefined;
+    reportDataInDays?: number | undefined;
+    timezone?: Timezone | undefined;
+    sentAt?: Date | undefined;
+  }): StatusPageReportPeriod {
+    const timezone: Timezone = data.timezone || this.DEFAULT_TIMEZONE;
+    const sentAt: Date = data.sentAt || OneUptimeDate.getCurrentDate();
+
+    if (data.periodType === StatusPageReportPeriodType.PreviousCalendarPeriod) {
+      return this.getPreviousCalendarPeriod({
+        reportRecurringInterval: data.reportRecurringInterval,
+        timezone: timezone,
+        sentAt: sentAt,
+      });
+    }
+
+    return this.getRollingPeriod({
+      reportDataInDays: data.reportDataInDays,
+      timezone: timezone,
+      sentAt: sentAt,
+    });
+  }
+
+  private static getRollingPeriod(data: {
+    reportDataInDays?: number | undefined;
+    timezone: Timezone;
+    sentAt: Date;
+  }): StatusPageReportPeriod {
+    const numberOfDays: number = this.toWholeDays(
+      data.reportDataInDays,
+      this.DEFAULT_REPORT_DATA_IN_DAYS,
+    );
+
+    const endDate: Date = data.sentAt;
+    const startDate: Date = OneUptimeDate.getSomeDaysAgoFromDate(
+      endDate,
+      numberOfDays,
+    );
+
+    return {
+      startDate: startDate,
+      endDate: endDate,
+      numberOfDays: numberOfDays,
+      timezone: data.timezone,
+      reportDates: `${numberOfDays} days (${this.formatDay(startDate, data.timezone)} - ${this.formatDay(endDate, data.timezone)})`,
+      periodName:
+        numberOfDays === 1 ? "the last day" : `the last ${numberOfDays} days`,
+    };
+  }
+
+  /*
+   * The last WHOLE calendar period before the report went out, sized by the
+   * send frequency. A monthly report sent at any point in August covers
+   * 1 Aug 00:00:00.000 minus one month through 31 Jul 23:59:59.999 - i.e. July,
+   * exactly as it reads on a calendar, in the status page's report timezone.
+   */
+  private static getPreviousCalendarPeriod(data: {
+    reportRecurringInterval?: Recurring | undefined;
+    timezone: Timezone;
+    sentAt: Date;
+  }): StatusPageReportPeriod {
+    const recurring: Recurring = data.reportRecurringInterval
+      ? Recurring.fromJSON(data.reportRecurringInterval)
+      : Recurring.getDefault();
+
+    const unit: CalendarUnit = Recurring.toCalendarUnit(recurring.intervalType);
+    const intervalCount: number = this.toWholeDays(
+      recurring.intervalCount?.toNumber(),
+      1,
+    );
+
+    /*
+     * Exclusive upper bound: the start of the period the report is being sent
+     * IN, which is the first instant not yet covered. The inclusive endDate
+     * below steps back a millisecond from it so the email reads "Jul 31" rather
+     * than "Aug 1".
+     */
+    const endExclusive: Date = OneUptimeDate.getStartOfCalendarUnit(
+      data.sentAt,
+      unit,
+      data.timezone,
+    );
+
+    const startDate: Date = OneUptimeDate.addRemoveCalendarUnits(
+      endExclusive,
+      unit,
+      -intervalCount,
+      data.timezone,
+    );
+
+    const endDate: Date = new Date(endExclusive.getTime() - 1);
+
+    return {
+      startDate: startDate,
+      endDate: endDate,
+      numberOfDays: Math.max(
+        1,
+        Math.round(
+          (endExclusive.getTime() - startDate.getTime()) /
+            OneUptimeDate.getMillisecondsInDays(1),
+        ),
+      ),
+      timezone: data.timezone,
+      reportDates: `${this.formatDay(startDate, data.timezone)} - ${this.formatDay(endDate, data.timezone)}`,
+      periodName: this.getCalendarPeriodName({
+        intervalType: recurring.intervalType,
+        intervalCount: intervalCount,
+        startDate: startDate,
+        endDate: endDate,
+        timezone: data.timezone,
+      }),
+    };
+  }
+
+  private static getCalendarPeriodName(data: {
+    intervalType: EventInterval;
+    intervalCount: number;
+    startDate: Date;
+    endDate: Date;
+    timezone: Timezone;
+  }): string {
+    /*
+     * Only a single-unit period has a name a reader already knows ("July 2026").
+     * Anything spanning several units, and hourly periods, are clearer as an
+     * explicit range.
+     */
+    if (data.intervalCount === 1) {
+      if (data.intervalType === EventInterval.Month) {
+        return this.format(data.startDate, "MMMM YYYY", data.timezone);
+      }
+
+      if (data.intervalType === EventInterval.Year) {
+        return this.format(data.startDate, "YYYY", data.timezone);
+      }
+
+      if (data.intervalType === EventInterval.Week) {
+        return `the week of ${this.formatDay(data.startDate, data.timezone)}`;
+      }
+
+      if (data.intervalType === EventInterval.Day) {
+        return this.formatDay(data.startDate, data.timezone);
+      }
+    }
+
+    return `${this.formatDay(data.startDate, data.timezone)} - ${this.formatDay(data.endDate, data.timezone)}`;
+  }
+
+  /*
+   * Guard against the nulls, decimals and zeroes a JSON column or a mid-edit
+   * form field can hold. A zero-length window would divide by zero downstream.
+   */
+  private static toWholeDays(
+    value: number | undefined | null,
+    fallback: number,
+  ): number {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+      return fallback;
+    }
+
+    return Math.floor(value);
+  }
+
+  private static formatDay(date: Date, timezone: Timezone): string {
+    return this.format(date, "MMM D, YYYY", timezone);
+  }
+
+  private static format(
+    date: Date,
+    format: string,
+    timezone: Timezone,
+  ): string {
+    return OneUptimeDate.getDateAsCustomFormattedStringInTimezone({
+      date: date,
+      format: format,
+      timezone: timezone,
+    });
+  }
+}

package/Utils/Telemetry/HostIpAddresses.ts

@@ -0,0 +1,98 @@
+/*
+ * Normalization for the OpenTelemetry `host.ip` resource attribute, which
+ * is an ARRAY of every address on every interface — not a single IP.
+ *
+ * On a Docker host with IPv6 enabled that array grows with the container
+ * count: the physical NIC, one address per docker bridge, one per veth,
+ * plus an IPv6 link-local per interface. 55 addresses / ~1450 characters
+ * has been observed in the wild (issue #3006), and there is no upper
+ * bound in the OTel spec.
+ *
+ * `Host.hostIpAddresses` is a `text` column so the realistic case is
+ * stored losslessly. These caps exist only so a pathological (or hostile)
+ * collector cannot push an unbounded blob into Postgres on every batch.
+ * They sit far above any plausible host, so in practice this function
+ * dedupes and joins and nothing else.
+ */
+
+/** Maximum number of addresses retained. */
+export const MAX_HOST_IP_ADDRESS_COUNT: number = 256;
+
+/** Maximum length of the serialized, comma-separated list. */
+export const MAX_HOST_IP_ADDRESSES_LENGTH: number = 10000;
+
+const SEPARATOR: string = ", ";
+
+/**
+ * Turn the raw `host.ip` values into the comma-separated string stored in
+ * `Host.hostIpAddresses`.
+ *
+ *   - blank / whitespace-only entries are dropped,
+ *   - each entry is trimmed,
+ *   - duplicates are removed case-insensitively (IPv6 hex casing is not
+ *     stable across resource detectors, so `FE80::1` and `fe80::1` are the
+ *     same address),
+ *   - source order is preserved — collectors report interfaces in a stable,
+ *     meaningful order and reordering would churn the Hosts table column,
+ *   - the result is capped by both address count and serialized length.
+ *
+ * Truncation always drops whole addresses from the tail. A half-written
+ * address would be worse than a missing one: it reads as a real address
+ * and there is no way for a consumer to tell it was cut.
+ *
+ * Returns `null` when nothing survives, so callers can leave the column
+ * untouched rather than writing an empty string.
+ */
+export function normalizeHostIpAddresses(
+  ipAddresses: Array<string> | null | undefined,
+): string | null {
+  if (!ipAddresses || ipAddresses.length === 0) {
+    return null;
+  }
+
+  const seen: Set<string> = new Set<string>();
+  const kept: Array<string> = [];
+  let serializedLength: number = 0;
+
+  for (const raw of ipAddresses) {
+    if (typeof raw !== "string") {
+      continue;
+    }
+
+    const trimmed: string = raw.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    const dedupeKey: string = trimmed.toLowerCase();
+    if (seen.has(dedupeKey)) {
+      continue;
+    }
+
+    const lengthWithSeparator: number =
+      trimmed.length + (kept.length > 0 ? SEPARATOR.length : 0);
+
+    if (serializedLength + lengthWithSeparator > MAX_HOST_IP_ADDRESSES_LENGTH) {
+      /*
+       * Stop rather than continue: entries are already ordered by the
+       * collector, so skipping this one to squeeze in a shorter later one
+       * would make the stored list order-dependent on address width.
+       */
+      break;
+    }
+
+    seen.add(dedupeKey);
+    kept.push(trimmed);
+    serializedLength += lengthWithSeparator;
+
+    if (kept.length >= MAX_HOST_IP_ADDRESS_COUNT) {
+      break;
+    }
+  }
+
+  if (kept.length === 0) {
+    return null;
+  }
+
+  return kept.join(SEPARATOR);
+}

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

@@ -49,6 +49,15 @@ let Host = class Host extends BaseModel {
         this.hostId = undefined;
         this.hostArch = undefined;
         this.hostType = undefined;
+        /*
+         * `text`, not varchar(500). A Docker/Kubernetes host with IPv6 enabled
+         * reports one host.ip entry per interface — physical NICs, docker
+         * bridges, every veth, plus an IPv6 link-local per interface. Real
+         * reports of 55 addresses / ~1450 characters exist, and the count grows
+         * with the number of containers, so any fixed bound is the wrong shape
+         * here. Overflowing it used to abort the whole Host metadata write and
+         * strand the host as "disconnected" (issue #3006).
+         */
         this.hostIpAddresses = undefined;
         this.cpuCores = undefined;
         this.totalMemoryBytes = undefined;
@@ -619,16 +628,15 @@ __decorate([
     }),
     TableColumn({
         required: false,
-        type: TableColumnType.LongText,
+        type: TableColumnType.VeryLongText,
         canReadOnRelationQuery: true,
         title: "Host IP Addresses",
-        description: "Comma-separated list of IP addresses reported by the OTel host.ip resource attribute. The first non-loopback IPv4 is used for display.",
+        description: "Comma-separated list of every IP address reported by the OTel host.ip resource attribute, in the order the collector reported them, deduplicated. The Hosts list shows the most routable one (IPv4, non-loopback, non-link-local) first; the host detail page groups them all by category.",
         example: "192.168.1.42, 10.0.0.5",
     }),
     Column({
         nullable: true,
-        type: ColumnType.LongText,
-        length: ColumnLength.LongText,
+        type: ColumnType.VeryLongText,
     }),
     __metadata("design:type", String)
 ], Host.prototype, "hostIpAddresses", void 0);