@oneuptime/common 12.0.2 → 12.0.3

package/Models/DatabaseModels/StatusPageResource.ts

@@ -3,6 +3,7 @@ import MonitorGroup from "./MonitorGroup";
 import Project from "./Project";
 import StatusPage from "./StatusPage";
 import StatusPageGroup from "./StatusPageGroup";
+import StatusPageMonitorRule from "./StatusPageMonitorRule";
 import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Route from "../../Types/API/Route";
@@ -520,6 +521,78 @@ export default class StatusPageResource extends BaseModel {
   })
   public statusPageGroupId?: ObjectID = undefined;
 
+  /*
+   * Set only on resources a StatusPageMonitorRule created. It is what lets the
+   * rule engine undo its own work without ever touching a resource a human
+   * added by hand, so it is deliberately not writable through the API - the
+   * engine sets it as root.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.StatusPageAdmin,
+      Permission.StatusPageMember,
+      Permission.StatusPageViewer,
+      Permission.ReadStatusPageResource,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "statusPageMonitorRuleId",
+    type: TableColumnType.Entity,
+    modelType: StatusPageMonitorRule,
+    title: "Status Page Monitor Rule",
+    description:
+      "Rule that added this resource to the status page, if it was added by a rule instead of by hand",
+  })
+  @ManyToOne(
+    () => {
+      return StatusPageMonitorRule;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "statusPageMonitorRuleId" })
+  public statusPageMonitorRule?: StatusPageMonitorRule = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.StatusPageAdmin,
+      Permission.StatusPageMember,
+      Permission.StatusPageViewer,
+      Permission.ReadStatusPageResource,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    title: "Status Page Monitor Rule ID",
+    description:
+      "ID of the rule that added this resource, if it was added by a rule instead of by hand",
+    example: "d0e1f2a3-b4c5-4678-9abc-def012345678",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public statusPageMonitorRuleId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/TraceDropFilter.ts

@@ -7,6 +7,7 @@ import TableAccessControl from "../../Types/Database/AccessControl/TableAccessCo
 import TableBillingAccessControl from "../../Types/Database/AccessControl/TableBillingAccessControl";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
+import { getBigIntDatabaseTransformer } from "../../Types/Database/BigIntColumnTransformer";
 import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
 import EnableDocumentation from "../../Types/Database/EnableDocumentation";
 import TableColumn from "../../Types/Database/TableColumn";
@@ -436,26 +437,14 @@ export default class TraceDropFilter extends BaseModel {
     type: ColumnType.BigPositiveNumber,
     nullable: false,
     default: 0,
-    transformer: {
-      to: (value: number | null | undefined): string | null => {
-        if (value === null || value === undefined) {
-          return null;
-        }
-        return Math.trunc(value).toString();
-      },
-      /*
-       * Postgres bigint comes back from the driver as a string. The UI
-       * renders this as a number, so normalize here rather than making
-       * every reader remember.
-       */
-      from: (value: string | null | undefined): number | null => {
-        if (value === null || value === undefined) {
-          return null;
-        }
-        const parsed: number = parseInt(value, 10);
-        return isNaN(parsed) ? null : parsed;
-      },
-    },
+    /*
+     * Shared transformer, not an inline one: it has to preserve `undefined`
+     * so this NOT NULL column's DEFAULT 0 is what a create actually gets.
+     * An inline transformer that mapped `undefined` to `null` made every
+     * drop-filter insert fail the not-null constraint. See
+     * Types/Database/BigIntColumnTransformer.
+     */
+    transformer: getBigIntDatabaseTransformer(),
   })
   public droppedCount?: number = undefined;
 

package/Server/API/BaseAPI.ts

@@ -22,6 +22,7 @@ import {
   LIMIT_PER_PROJECT,
 } from "../../Types/Database/LimitMax";
 import PartialEntity from "../../Types/Database/PartialEntity";
+import { coerceNumericColumnsInJSON } from "../../Types/Database/NumericColumnValue";
 import BadDataException from "../../Types/Exception/BadDataException";
 import BadRequestException from "../../Types/Exception/BadRequestException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
@@ -418,8 +419,18 @@ export default class BaseAPI<
       );
     }
 
-    const item: PartialEntity<TBaseModel> = JSONFunctions.deserialize(
-      dataInBody as JSONObject,
+    /*
+     * Coerced the same way createItem's BaseModel.fromJSON coerces, so a
+     * PATCH and a POST agree on what a number column holds. The dashboard's
+     * number fields are `<input type="number">`, whose value is a string,
+     * and the save-time hooks read these values before Postgres would
+     * coerce them — a sample percentage of "10" was rejected as "not a
+     * number" on a form that had one filled in.
+     * github.com/OneUptime/oneuptime/issues/3027
+     */
+    const item: PartialEntity<TBaseModel> = coerceNumericColumnsInJSON(
+      JSONFunctions.deserialize(dataInBody as JSONObject),
+      new this.entityType(),
     ) as PartialEntity<TBaseModel>;
 
     delete (item as any)["_id"];

package/Server/API/DashboardAPI.ts

@@ -50,6 +50,7 @@ import PodmanResource from "../../Models/DatabaseModels/PodmanResource";
 import ProxmoxResource from "../../Models/DatabaseModels/ProxmoxResource";
 import CephResource from "../../Models/DatabaseModels/CephResource";
 import DockerSwarmResource from "../../Models/DatabaseModels/DockerSwarmResource";
+import NetworkSite from "../../Models/DatabaseModels/NetworkSite";
 import Span from "../../Models/AnalyticsModels/Span";
 import Log from "../../Models/AnalyticsModels/Log";
 import IncidentService from "../Services/IncidentService";
@@ -64,6 +65,7 @@ import PodmanResourceService from "../Services/PodmanResourceService";
 import ProxmoxResourceService from "../Services/ProxmoxResourceService";
 import CephResourceService from "../Services/CephResourceService";
 import DockerSwarmResourceService from "../Services/DockerSwarmResourceService";
+import NetworkSiteService from "../Services/NetworkSiteService";
 import SpanService from "../Services/SpanService";
 import LogService from "../Services/LogService";
 import DashboardComponentType from "../../Types/Dashboard/DashboardComponentType";
@@ -165,6 +167,43 @@ const PUBLIC_DASHBOARD_RESOURCES: Record<
       currentMonitorStatus: { name: true, color: true },
     },
   },
+  "network-site": {
+    modelType: NetworkSite,
+    service: NetworkSiteService,
+    widgets: {
+      [DashboardComponentType.NetworkMap]: null,
+    },
+    /*
+     * The map filters by site type and by whether the rolled-up status is
+     * operational — nothing else. Notably NOT `parentSiteId` or
+     * `materializedPath`: the widget draws a flat set of pins rather than
+     * walking a hierarchy, so exposing the tree shape here would hand an
+     * anonymous viewer a structure the map never shows them.
+     */
+    allowedQueryKeys: [
+      "networkSiteTypeId",
+      "currentMonitorStatus",
+      "currentMonitorStatusId",
+    ],
+    select: {
+      _id: true,
+      name: true,
+      /*
+       * The type NAME comes from the networkSiteType relation. NetworkSite
+       * .siteType is the deprecated pre-lookup-table string and is dropped
+       * in a follow-up PR, so it must not be read from new code.
+       */
+      networkSiteType: { name: true },
+      latitude: true,
+      longitude: true,
+      currentMonitorStatus: {
+        name: true,
+        color: true,
+        priority: true,
+        isOperationalState: true,
+      },
+    },
+  },
   host: {
     modelType: Host,
     service: HostService,

package/Server/EnvironmentConfig.ts

@@ -167,13 +167,43 @@ export const PostgresStatementTimeoutMs: number = parseInt(
   10,
 );
 
+/*
+ * Postgres-side lock timeout (ms). Caps how long a statement will WAIT for a
+ * row/table lock before giving up — distinct from statement_timeout, which
+ * caps total execution.
+ *
+ * Without it, contention on a hot row degrades into a strictly-ordered queue:
+ * every waiter pins a backend for the sum of everyone ahead of it. That is the
+ * row-lock convoy that took production down — 892 connections parked on locks,
+ * the tail waiting 3.7 hours — and no amount of database capacity changes it,
+ * because the queue itself is the failure. A short lock_timeout converts an
+ * unbounded wait into a fast, retryable error.
+ *
+ * Must stay well below statement_timeout so a lock wait surfaces as
+ * `lock_not_available` (55P03) rather than a generic statement timeout — the
+ * two want very different handling.
+ */
+export const PostgresLockTimeoutMs: number = parseInt(
+  process.env["DATABASE_LOCK_TIMEOUT_MS"] || "3000",
+  10,
+);
+
 /*
  * Node-postgres client-side query timeout (ms). Belt-and-braces for the
  * server-side statement_timeout — fires even if the connection has gone
  * silent or the server-side timeout doesn't kick in.
+ *
+ * Deliberately LONGER than statement_timeout. These two used to be equal, and
+ * because the client timer starts before the packet even reaches the backend,
+ * the client always won by a round trip — so the app never observed Postgres's
+ * real SQLSTATE and, worse, the client-side timeout only ABANDONS the query:
+ * the backend keeps running and keeps its place in the lock queue. Letting the
+ * server win means contention is cancelled server-side instead of accumulating
+ * invisibly behind a pooler.
  */
 export const PostgresQueryTimeoutMs: number = parseInt(
-  process.env["DATABASE_QUERY_TIMEOUT_MS"] || "30000",
+  process.env["DATABASE_QUERY_TIMEOUT_MS"] ||
+    String(PostgresStatementTimeoutMs + 5000),
   10,
 );
 

package/Server/Infrastructure/GlobalCache.ts

@@ -176,6 +176,121 @@ export default abstract class GlobalCache {
     await client.set(`${namespace}-${key}`, value, "EX", expiresInSeconds);
   }
 
+  /*
+   * Atomic acquire-once fence: SET ... EX ... NX. Returns true ONLY for the
+   * caller that created the key; every concurrent caller gets false until it
+   * expires.
+   *
+   * This exists because `getString()` followed by `setString()` is a
+   * check-then-act race, and at ingest concurrency that race is not
+   * theoretical — it is the whole problem. When N workers resolve the same
+   * row in the same instant they ALL read a miss and they ALL proceed, so a
+   * fence meant to admit one writer per window admits N. With 100 worker pods
+   * that turned a once-a-minute heartbeat into thousands of simultaneous
+   * UPDATEs against the same handful of rows, and the resulting row-lock
+   * convoy starved the Postgres connection pool (some statements queued for
+   * hours). Redis evaluates SET NX atomically, so exactly one caller wins no
+   * matter how many arrive together.
+   *
+   * Fence keys should carry the TTL jitter from `withJitter()` — see there for
+   * why synchronized expiry re-creates the herd this is meant to prevent.
+   */
+  @CaptureSpan()
+  public static async setStringIfNotExists(
+    namespace: string,
+    key: string,
+    value: string,
+    options?: CacheSetOptions,
+  ): Promise<boolean> {
+    const client: ClientType | null = Redis.getClient();
+
+    if (!client || !Redis.isConnected()) {
+      throw new DatabaseNotConnectedException("Cache is not connected");
+    }
+
+    const expiresInSeconds: number =
+      options?.expiresInSeconds ?? OneUptimeDate.getSecondsInDays(30);
+
+    const result: string | null = await client.set(
+      `${namespace}-${key}`,
+      value,
+      "EX",
+      expiresInSeconds,
+      "NX",
+    );
+
+    /*
+     * ioredis resolves to "OK" when the key was created and to null when it
+     * already existed. Anything else (a driver/protocol change) is treated as
+     * "did not acquire" — losing the fence is safe, winning it wrongly is not.
+     */
+    return result === "OK";
+  }
+
+  /*
+   * Atomic compare-and-claim: claim the window unless the key ALREADY holds
+   * `value`. Returns true only for the caller that claimed it.
+   *
+   * `setStringIfNotExists` is the right primitive for a presence fence and the
+   * wrong one for a fingerprint throttle. Plain NX fails whenever the key
+   * exists — including when it holds a STALE fingerprint — so a genuinely
+   * changed payload (a new service.version after a deploy, a changed host IP)
+   * would be suppressed for the whole window and nobody would persist it. This
+   * keeps the bust-on-change behaviour that callers depend on while collapsing
+   * the GET-then-SET race into one atomic evaluation.
+   *
+   * The key is passed as KEYS[1] rather than inlined into the script body so
+   * the script stays correct on Redis Cluster, which routes by declared keys.
+   */
+  @CaptureSpan()
+  public static async setStringIfChanged(
+    namespace: string,
+    key: string,
+    value: string,
+    options?: CacheSetOptions,
+  ): Promise<boolean> {
+    const client: ClientType | null = Redis.getClient();
+
+    if (!client || !Redis.isConnected()) {
+      throw new DatabaseNotConnectedException("Cache is not connected");
+    }
+
+    const expiresInSeconds: number =
+      options?.expiresInSeconds ?? OneUptimeDate.getSecondsInDays(30);
+
+    const result: unknown = await client.eval(
+      "if redis.call('GET', KEYS[1]) == ARGV[1] then return 0 " +
+        "else redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[2]) return 1 end",
+      1,
+      `${namespace}-${key}`,
+      value,
+      String(expiresInSeconds),
+    );
+
+    return result === 1;
+  }
+
+  /*
+   * Spread a fence TTL over [ttl, ttl + 25%].
+   *
+   * A fixed TTL makes every fence for a fleet of rows expire in lockstep once
+   * their writes have been aligned by a common event — a deploy, a worker
+   * scale-up, a Redis restart. The window then reopens for thousands of rows
+   * in the same second and the herd re-forms on a one-minute period. Jitter
+   * breaks that alignment permanently: the fences drift apart after the first
+   * window and stay apart.
+   *
+   * The upper bound stays well inside the 15-minute disconnection sweep, so a
+   * jittered heartbeat can never make a live resource look disconnected.
+   */
+  public static withJitter(expiresInSeconds: number): number {
+    if (expiresInSeconds <= 0) {
+      return expiresInSeconds;
+    }
+
+    return Math.ceil(expiresInSeconds * (1 + Math.random() * 0.25));
+  }
+
   @CaptureSpan()
   public static async deleteKey(namespace: string, key: string): Promise<void> {
     const client: ClientType | null = Redis.getClient();

package/Server/Infrastructure/Postgres/DataSourceOptions.ts

@@ -10,6 +10,7 @@ import {
   DatabaseUsername,
   MaxPostgresConnections,
   PostgresConnectionAcquireTimeoutMs,
+  PostgresLockTimeoutMs,
   PostgresIdleInTransactionTimeoutMs,
   PostgresIdleSessionTimeoutMs,
   PostgresIdleTimeoutMs,
@@ -61,6 +62,21 @@ const dataSourceOptions: DataSourceOptions = {
     statement_timeout: PostgresStatementTimeoutMs,
     query_timeout: PostgresQueryTimeoutMs,
     idle_in_transaction_session_timeout: PostgresIdleInTransactionTimeoutMs,
+    /*
+     * Bound how long a statement WAITS for a lock, so contention on a hot row
+     * fails fast instead of forming a queue (see PostgresLockTimeoutMs).
+     *
+     * Excluded on the migration path, and that exclusion is load-bearing:
+     * App/Migrate.ts loads these same options and connects DIRECTLY to the
+     * backend (bypassing any pooler), where startup parameters really do take
+     * effect. A 3s lock_timeout there would abort ACCESS EXCLUSIVE DDL on any
+     * table with live traffic — only the two migrations that set their own
+     * `SET LOCAL lock_timeout` expect to fail that way; the rest must be free
+     * to wait.
+     */
+    ...(PostgresLockTimeoutMs > 0 && !RunDatabaseMigrationsOnBoot
+      ? { lock_timeout: PostgresLockTimeoutMs }
+      : {}),
     /*
      * Detect dead TCP peers (ungraceful client exit / network partition) so
      * orphaned server-side connections get torn down instead of lingering

package/Server/Infrastructure/Postgres/SchemaMigrations/1786005052769-AddStatusPageMonitorRule.ts

@@ -0,0 +1,123 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddStatusPageMonitorRule1786005052769
+  implements MigrationInterface
+{
+  public name = "AddStatusPageMonitorRule1786005052769";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "StatusPageMonitorRule" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "statusPageId" uuid NOT NULL, "name" character varying(100) NOT NULL, "description" character varying(500), "isEnabled" boolean NOT NULL DEFAULT true, "monitorNamePattern" character varying(500), "monitorDescriptionPattern" character varying(500), "statusPageGroupId" uuid, "showCurrentStatus" boolean NOT NULL DEFAULT true, "showUptimePercent" boolean NOT NULL DEFAULT true, "uptimePercentPrecision" character varying, "showStatusHistoryChart" boolean NOT NULL DEFAULT true, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_f8d44792805d19b9a80921b6aa6" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_1dfd95ad32f7b687ef4d7ba591" ON "StatusPageMonitorRule" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_473317deaa55a8305a047e4098" ON "StatusPageMonitorRule" ("statusPageId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_61196848685b7e7f5a6a54278b" ON "StatusPageMonitorRule" ("name") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_71d1869039530178fd5f7e6faa" ON "StatusPageMonitorRule" ("isEnabled") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3e6d0bc4d444371aaa13a1c14c" ON "StatusPageMonitorRule" ("statusPageGroupId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "StatusPageMonitorRuleMonitorLabel" ("statusPageMonitorRuleId" uuid NOT NULL, "labelId" uuid NOT NULL, CONSTRAINT "PK_59234d33b435d8e771cd3728ea4" PRIMARY KEY ("statusPageMonitorRuleId", "labelId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0eb2b2a3601ea9813b8e162bd3" ON "StatusPageMonitorRuleMonitorLabel" ("statusPageMonitorRuleId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_bc08b888a870ecc9167516230a" ON "StatusPageMonitorRuleMonitorLabel" ("labelId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageResource" ADD "statusPageMonitorRuleId" uuid`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_4e1ed45d9506da817dc7811601" ON "StatusPageResource" ("statusPageMonitorRuleId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" ADD CONSTRAINT "FK_1dfd95ad32f7b687ef4d7ba5910" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" ADD CONSTRAINT "FK_473317deaa55a8305a047e4098b" FOREIGN KEY ("statusPageId") REFERENCES "StatusPage"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" ADD CONSTRAINT "FK_3e6d0bc4d444371aaa13a1c14cc" FOREIGN KEY ("statusPageGroupId") REFERENCES "StatusPageGroup"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" ADD CONSTRAINT "FK_60d22031be1695cbd1405376cbf" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" ADD CONSTRAINT "FK_3416ec12899c9dde670d8dea290" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageResource" ADD CONSTRAINT "FK_4e1ed45d9506da817dc78116010" FOREIGN KEY ("statusPageMonitorRuleId") REFERENCES "StatusPageMonitorRule"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRuleMonitorLabel" ADD CONSTRAINT "FK_0eb2b2a3601ea9813b8e162bd3b" FOREIGN KEY ("statusPageMonitorRuleId") REFERENCES "StatusPageMonitorRule"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRuleMonitorLabel" ADD CONSTRAINT "FK_bc08b888a870ecc9167516230ad" FOREIGN KEY ("labelId") REFERENCES "Label"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRuleMonitorLabel" DROP CONSTRAINT "FK_bc08b888a870ecc9167516230ad"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRuleMonitorLabel" DROP CONSTRAINT "FK_0eb2b2a3601ea9813b8e162bd3b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageResource" DROP CONSTRAINT "FK_4e1ed45d9506da817dc78116010"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" DROP CONSTRAINT "FK_3416ec12899c9dde670d8dea290"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" DROP CONSTRAINT "FK_60d22031be1695cbd1405376cbf"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" DROP CONSTRAINT "FK_3e6d0bc4d444371aaa13a1c14cc"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" DROP CONSTRAINT "FK_473317deaa55a8305a047e4098b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageMonitorRule" DROP CONSTRAINT "FK_1dfd95ad32f7b687ef4d7ba5910"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_4e1ed45d9506da817dc7811601"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageResource" DROP COLUMN "statusPageMonitorRuleId"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_bc08b888a870ecc9167516230a"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0eb2b2a3601ea9813b8e162bd3"`,
+    );
+    await queryRunner.query(`DROP TABLE "StatusPageMonitorRuleMonitorLabel"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_3e6d0bc4d444371aaa13a1c14c"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_71d1869039530178fd5f7e6faa"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_61196848685b7e7f5a6a54278b"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_473317deaa55a8305a047e4098"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_1dfd95ad32f7b687ef4d7ba591"`,
+    );
+    await queryRunner.query(`DROP TABLE "StatusPageMonitorRule"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -498,6 +498,7 @@ import { WidenInventoryResourceNameColumns1785930000000 } from "./1785930000000-
 import { AddStatusPageReportPeriod1785930709405 } from "./1785930709405-AddStatusPageReportPeriod";
 import { AddIncidentInvestigationGating1785790000000 } from "./1785790000000-AddIncidentInvestigationGating";
 import { AddRemediationVerification1785768089408 } from "./1785768089408-AddRemediationVerification";
+import { AddStatusPageMonitorRule1786005052769 } from "./1786005052769-AddStatusPageMonitorRule";
 
 export default [
   InitialMigration,
@@ -1000,4 +1001,5 @@ export default [
   IncreaseHostIpAddressesLength1785915638551,
   WidenInventoryResourceNameColumns1785930000000,
   AddStatusPageReportPeriod1785930709405,
+  AddStatusPageMonitorRule1786005052769,
 ];

package/Server/Services/AlertStateTimelineService.ts

@@ -19,6 +19,7 @@ import { JSONObject } from "../../Types/JSON";
 import AlertInternalNote from "../../Models/DatabaseModels/AlertInternalNote";
 import AlertInternalNoteService from "./AlertInternalNoteService";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ProjectScopedReferenceValidator from "../Utils/Database/ProjectScopedReferenceValidator";
 import logger, { LogAttributes } from "../Utils/Logger";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
@@ -118,6 +119,25 @@ export class Service extends DatabaseService<AlertStateTimeline> {
         throw new BadDataException("alertStateId is null");
       }
 
+      /*
+       * Same guard, same reason, as MonitorStatusTimelineService: an id that
+       * exists nowhere (or belongs to another project) used to reach Postgres
+       * and come back as a raw foreign key violation. The ordering check below
+       * does look the state up, but only when there IS a preceding row with an
+       * order, so the first timeline row for an alert went through unchecked.
+       */
+      await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+        projectId: createBy.props.tenantId || createBy.data.projectId,
+        subject: "alert state timeline",
+        references: [
+          {
+            modelName: "Alert State",
+            id: alertStateId,
+            service: AlertStateService,
+          },
+        ],
+      });
+
       const stateBeforeThis: AlertStateTimeline | null = await this.findOneBy({
         query: {
           alertId: createBy.data.alertId,