@oneuptime/common 10.4.13 → 10.4.15

package/Server/API/StatusAPI.ts

@@ -1,4 +1,5 @@
 import BadRequestException from "../../Types/Exception/BadRequestException";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 import LocalCache from "../Infrastructure/LocalCache";
 import Express, {
   ExpressRequest,
@@ -20,7 +21,93 @@ export interface StatusAPIOptions {
   databaseCheck?: (() => Promise<void>) | undefined;
 }
 
+/**
+ * Result of a recently executed health check, cached for HEALTH_CHECK_CACHE_TTL_MS.
+ * We cache both success AND failure: caching failure protects an already
+ * unhealthy backend from being hammered by retry traffic during an outage. The
+ * 5s TTL is short enough that k8s probe semantics (default 10s interval,
+ * failureThreshold 3 → ~30s to unready) are essentially unchanged.
+ */
+type CachedHealthCheckResult = { ok: true } | { ok: false; error: Error };
+
 export default class StatusAPI {
+  /**
+   * Cache of recent health check results, keyed by check name. Each entry
+   * lives for HEALTH_CHECK_CACHE_TTL_MS. Bounded to a small max size — there
+   * are only ~5 distinct check names in this API.
+   */
+  private static checkResultCache: InMemoryTTLCache<CachedHealthCheckResult> =
+    new InMemoryTTLCache<CachedHealthCheckResult>(64);
+
+  /**
+   * In-flight check promises keyed by check name. When a cache miss occurs
+   * and multiple concurrent requests arrive, they all attach to the same
+   * promise instead of each triggering their own DB query. The entry is
+   * cleared as soon as the check settles.
+   */
+  private static inflightChecks: Map<string, Promise<void>> = new Map();
+
+  /**
+   * Cache TTL for health-check results. Chosen so that:
+   *   - Two-thirds of typical k8s probes (default periodSeconds=10) hit
+   *     the cache, removing constant DB load from liveness/readiness traffic.
+   *   - Time-to-detect for a failing dependency only grows by ≤5s, which is
+   *     well within the failureThreshold window k8s probes already tolerate.
+   */
+  private static readonly HEALTH_CHECK_CACHE_TTL_MS: number = 5000;
+
+  /**
+   * Runs `checkFn` with two layers of protection:
+   *   1. TTL cache — if the same check ran in the last HEALTH_CHECK_CACHE_TTL_MS
+   *      ms, reuse its result (success or failure) without re-running.
+   *   2. Single-flight — if a check is already in flight, concurrent callers
+   *      await the same promise instead of starting their own.
+   *
+   * On cache hit this is effectively free; on cache miss we run the check
+   * exactly once regardless of how many requests arrived concurrently.
+   */
+  private static async runCachedCheck(
+    checkName: string,
+    checkFn: () => Promise<void>,
+  ): Promise<void> {
+    const cached: CachedHealthCheckResult | undefined =
+      this.checkResultCache.get(checkName);
+    if (cached) {
+      if (cached.ok) {
+        return;
+      }
+      throw cached.error;
+    }
+
+    let inflight: Promise<void> | undefined =
+      this.inflightChecks.get(checkName);
+    if (!inflight) {
+      inflight = (async (): Promise<void> => {
+        try {
+          await checkFn();
+          this.checkResultCache.set(
+            checkName,
+            { ok: true },
+            this.HEALTH_CHECK_CACHE_TTL_MS,
+          );
+        } catch (e) {
+          const error: Error = e instanceof Error ? e : new Error(String(e));
+          this.checkResultCache.set(
+            checkName,
+            { ok: false, error },
+            this.HEALTH_CHECK_CACHE_TTL_MS,
+          );
+          throw error;
+        } finally {
+          this.inflightChecks.delete(checkName);
+        }
+      })();
+      this.inflightChecks.set(checkName, inflight);
+    }
+
+    await inflight;
+  }
+
   @CaptureSpan()
   public static init(options: StatusAPIOptions): ExpressRouter {
     const statusCheckSuccessCounter: TelemetryCounter = Telemetry.getCounter({
@@ -127,8 +214,11 @@ export default class StatusAPI {
     res: ExpressResponse,
   ): Promise<void> {
     try {
-      logger.info("Ready check: Init", getLogAttributesFromRequest(req as any));
-      await options.readyCheck();
+      /*
+       * Cached for HEALTH_CHECK_CACHE_TTL_MS so k8s probe traffic does not
+       * hammer the underlying check on every request.
+       */
+      await this.runCachedCheck("ready", options.readyCheck);
       logger.info("Ready check: ok", getLogAttributesFromRequest(req as any));
       stausReadySuccess.add(1);
 
@@ -160,8 +250,8 @@ export default class StatusAPI {
     res: ExpressResponse,
   ): Promise<void> {
     try {
-      logger.info("Live check: Init", getLogAttributesFromRequest(req as any));
-      await options.liveCheck();
+      // Cached for HEALTH_CHECK_CACHE_TTL_MS — see runCachedCheck for rationale.
+      await this.runCachedCheck("live", options.liveCheck);
       logger.info("Live check: ok", getLogAttributesFromRequest(req as any));
       stausLiveSuccess.add(1);
 
@@ -195,7 +285,8 @@ export default class StatusAPI {
         getLogAttributesFromRequest(req as any),
       );
       if (options.globalCacheCheck) {
-        await options.globalCacheCheck();
+        // Cached — see runCachedCheck for rationale.
+        await this.runCachedCheck("global-cache", options.globalCacheCheck);
       } else {
         throw new BadRequestException("Global cache check not implemented");
       }
@@ -230,7 +321,11 @@ export default class StatusAPI {
         getLogAttributesFromRequest(req as any),
       );
       if (options.analyticsDatabaseCheck) {
-        await options.analyticsDatabaseCheck();
+        // Cached — see runCachedCheck for rationale.
+        await this.runCachedCheck(
+          "analytics-database",
+          options.analyticsDatabaseCheck,
+        );
       } else {
         throw new BadRequestException(
           "Analytics database check not implemented",
@@ -265,7 +360,8 @@ export default class StatusAPI {
       logger.debug("Database check", getLogAttributesFromRequest(req as any));
 
       if (options.databaseCheck) {
-        await options.databaseCheck();
+        // Cached — see runCachedCheck for rationale.
+        await this.runCachedCheck("database", options.databaseCheck);
       } else {
         throw new BadRequestException("Database check not implemented");
       }

package/Server/EnvironmentConfig.ts

@@ -145,6 +145,75 @@ export const ShouldDatabaseSslEnable: boolean = Boolean(
   DatabaseSslCa || (DatabaseSslCert && DatabaseSslKey),
 );
 
+/*
+ * Postgres pool size per API/Worker node. TypeORM's default is 10 which
+ * starves the API under any meaningful load — pick a number that, when
+ * multiplied by the number of running Node processes, stays under the
+ * Postgres server's `max_connections` (default 100 on a stock cluster).
+ */
+export const MaxPostgresConnections: number = parseInt(
+  process.env["DATABASE_MAX_OPEN_CONNECTIONS"] || "50",
+  10,
+);
+
+/*
+ * Postgres-side statement timeout (ms). Caps the wall-clock time of any
+ * single SQL statement. Without this, a single runaway query can pin a
+ * connection forever and starve the pool.
+ */
+export const PostgresStatementTimeoutMs: number = parseInt(
+  process.env["DATABASE_STATEMENT_TIMEOUT_MS"] || "30000",
+  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.
+ */
+export const PostgresQueryTimeoutMs: number = parseInt(
+  process.env["DATABASE_QUERY_TIMEOUT_MS"] || "30000",
+  10,
+);
+
+/*
+ * Postgres-side idle-in-transaction timeout (ms). Kills connections that
+ * are stuck holding row locks inside a BEGIN without committing.
+ */
+export const PostgresIdleInTransactionTimeoutMs: number = parseInt(
+  process.env["DATABASE_IDLE_IN_TRANSACTION_TIMEOUT_MS"] || "60000",
+  10,
+);
+
+/*
+ * pg-pool acquire timeout (ms). How long a query waits for a free
+ * connection before failing. Without this, requests pile up invisibly
+ * when the pool is exhausted.
+ */
+export const PostgresConnectionAcquireTimeoutMs: number = parseInt(
+  process.env["DATABASE_CONNECTION_TIMEOUT_MS"] || "5000",
+  10,
+);
+
+/*
+ * pg-pool idle connection timeout (ms). Closes connections that have
+ * been sitting unused for this long, freeing server-side slots.
+ */
+export const PostgresIdleTimeoutMs: number = parseInt(
+  process.env["DATABASE_IDLE_TIMEOUT_MS"] || "30000",
+  10,
+);
+
+/*
+ * TypeORM slow-query log threshold (ms). Any query exceeding this is
+ * logged so we can find offenders in production without per-query
+ * tracing. Set to 0 to disable.
+ */
+export const PostgresSlowQueryLogThresholdMs: number = parseInt(
+  process.env["DATABASE_SLOW_QUERY_LOG_THRESHOLD_MS"] || "1000",
+  10,
+);
+
 export const EncryptionSecret: ObjectID = new ObjectID(
   process.env["ENCRYPTION_SECRET"] || "secret",
 );

package/Server/Infrastructure/Postgres/DataSourceOptions.ts

@@ -8,6 +8,13 @@ import {
   DatabaseSslCert,
   DatabaseSslKey,
   DatabaseUsername,
+  MaxPostgresConnections,
+  PostgresConnectionAcquireTimeoutMs,
+  PostgresIdleInTransactionTimeoutMs,
+  PostgresIdleTimeoutMs,
+  PostgresQueryTimeoutMs,
+  PostgresSlowQueryLogThresholdMs,
+  PostgresStatementTimeoutMs,
   ShouldDatabaseSslEnable,
 } from "../../../Server/EnvironmentConfig";
 import Migrations from "./SchemaMigrations/Index";
@@ -35,7 +42,25 @@ const dataSourceOptions: DataSourceOptions = {
         cert: DatabaseSslCert,
       }
     : false,
-  // logging: 'all',
+  /*
+   * Anything in `extra` is forwarded to the underlying node-postgres pool
+   * and client. Pool sizing + timeouts live here because TypeORM's defaults
+   * (10 connections, no timeouts) are too small for any non-trivial load.
+   */
+  extra: {
+    max: MaxPostgresConnections,
+    idleTimeoutMillis: PostgresIdleTimeoutMs,
+    connectionTimeoutMillis: PostgresConnectionAcquireTimeoutMs,
+    statement_timeout: PostgresStatementTimeoutMs,
+    query_timeout: PostgresQueryTimeoutMs,
+    idle_in_transaction_session_timeout: PostgresIdleInTransactionTimeoutMs,
+  },
+  /*
+   * Log any query slower than the configured threshold so we can find
+   * offenders in production. TypeORM emits these via the configured
+   * logger; the default `advanced-console` logger writes to stdout.
+   */
+  maxQueryExecutionTime: PostgresSlowQueryLogThresholdMs,
   synchronize: false,
 };
 

package/Server/Infrastructure/Postgres/SchemaMigrations/1779392865146-AddAgentVersionToKubernetesDockerHost.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddAgentVersionToKubernetesDockerHost1779392865146
+  implements MigrationInterface
+{
+  name = "AddAgentVersionToKubernetesDockerHost1779392865146";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "agentVersion" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerHost" ADD "agentVersion" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Host" ADD "agentVersion" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "Host" DROP COLUMN "agentVersion"`);
+    await queryRunner.query(
+      `ALTER TABLE "DockerHost" DROP COLUMN "agentVersion"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "agentVersion"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779392970424-AddPerformanceIndexes.ts

@@ -0,0 +1,160 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddPerformanceIndexes1779392970424 implements MigrationInterface {
+  public name: string = "AddPerformanceIndexes1779392970424";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Active-X badge counters on the dashboard.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d846ce00a02d1073efc07178fa" ON "Incident" ("projectId", "currentIncidentStateId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0c7286dfa90fd7d8201ec6f217" ON "Alert" ("projectId", "currentAlertStateId") `,
+    );
+
+    // Alert filtering by monitor (monitor detail page).
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b57071fc2f1e27430e651382ee" ON "Alert" ("monitorId") `,
+    );
+
+    // Notification log tables: filter by project + status / time range.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8a0f032f20cd845c9bb908f38c" ON "CallLog" ("projectId", "status") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b59ee5f702882c10066cdd1128" ON "CallLog" ("projectId", "createdAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8f4eea9e7f20eaf121625f5787" ON "EmailLog" ("projectId", "status") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_33d38c24249a256f89001acf83" ON "EmailLog" ("projectId", "createdAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c37d2fcfcb591afb284dad27d9" ON "SmsLog" ("projectId", "status") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c6bbede6b3bb66781bc7c82463" ON "SmsLog" ("projectId", "createdAt") `,
+    );
+
+    // Feed timelines on alert/incident/monitor detail pages.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_6f97cb7c189e6339cf364a3608" ON "AlertFeed" ("alertId", "postedAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e26bf84ec503bbfb06bcde139e" ON "IncidentFeed" ("incidentId", "postedAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_5771fc57305fb0f508153b53ce" ON "MonitorFeed" ("monitorId", "postedAt") `,
+    );
+
+    // Monitor probe scheduler.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_4bf4109d325af5e5b5a5665bc7" ON "MonitorProbe" ("probeId", "isEnabled", "nextPingAt") `,
+    );
+
+    // On-call duty time logs (active-on-call lookups).
+    await queryRunner.query(
+      `CREATE INDEX "IDX_43da7ffeee531e9452d36a89ba" ON "OnCallDutyPolicyTimeLog" ("userId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_977d907fb45cbc1a2067f490af" ON "OnCallDutyPolicyTimeLog" ("startsAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_002727a958120be971790fd016" ON "OnCallDutyPolicyTimeLog" ("endsAt") `,
+    );
+
+    // Telemetry exceptions dashboard.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_fa102ae5073b428e514cc2ceea" ON "TelemetryException" ("occuranceCount") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3836772be478de8a9df86a938d" ON "TelemetryException" ("projectId", "isResolved", "isArchived") `,
+    );
+
+    // Status page subscriber dedupe.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c28628545faa67976e1d462e69" ON "StatusPageSubscriber" ("statusPageId", "subscriberPhone") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3a2d83fc5107c639d10a7c5cc0" ON "StatusPageSubscriber" ("statusPageId", "subscriberEmail") `,
+    );
+
+    // Worker sweeps.
+    await queryRunner.query(
+      `CREATE INDEX "IDX_094b044a3d6a79695ba754cdfb" ON "UserOnCallLog" ("status") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_7a5dc4760803e57f2d0b363e6e" ON "WorkflowLog" ("workflowStatus", "createdAt") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_7a5dc4760803e57f2d0b363e6e"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_094b044a3d6a79695ba754cdfb"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_3a2d83fc5107c639d10a7c5cc0"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c28628545faa67976e1d462e69"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_3836772be478de8a9df86a938d"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_fa102ae5073b428e514cc2ceea"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_002727a958120be971790fd016"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_977d907fb45cbc1a2067f490af"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_43da7ffeee531e9452d36a89ba"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_4bf4109d325af5e5b5a5665bc7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_5771fc57305fb0f508153b53ce"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e26bf84ec503bbfb06bcde139e"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_6f97cb7c189e6339cf364a3608"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c6bbede6b3bb66781bc7c82463"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c37d2fcfcb591afb284dad27d9"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_33d38c24249a256f89001acf83"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_8f4eea9e7f20eaf121625f5787"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b59ee5f702882c10066cdd1128"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_8a0f032f20cd845c9bb908f38c"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b57071fc2f1e27430e651382ee"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0c7286dfa90fd7d8201ec6f217"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d846ce00a02d1073efc07178fa"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779536271671-AddFacetsToTableView.ts

@@ -0,0 +1,13 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddFacetsToTableView1779536271671 implements MigrationInterface {
+  public name: string = "AddFacetsToTableView1779536271671";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "TableView" ADD "facets" jsonb`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "TableView" DROP COLUMN "facets"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779540427366-AddIsMemberNotifiedIndex.ts

@@ -0,0 +1,34 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Adds an index on `IncidentMember.isMemberNotified`. The
+ * `IncidentMembers/SendMemberAddedNotification` cron polls
+ * `WHERE isMemberNotified = false` every minute; without the
+ * index that's a full table scan that scales with every
+ * incident-member assignment ever made.
+ *
+ * The autogenerated diff also picked up unrelated drift between
+ * the local dev database and the current entity models (drops
+ * of `User.themePreference`, `StatusPage.showGridView`,
+ * `StatusPageResource.statusPageGridColumnId`, and ALTER COLUMN
+ * default changes on `OnCallDutyPolicyScheduleLayer`). Those
+ * changes belong to other branches and must not run here — they
+ * were stripped to keep this migration tightly scoped.
+ */
+export class AddIsMemberNotifiedIndex1779540427366
+  implements MigrationInterface
+{
+  public name: string = "AddIsMemberNotifiedIndex1779540427366";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0c2358ce5ea46732d76c4cbb26" ON "IncidentMember" ("isMemberNotified") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0c2358ce5ea46732d76c4cbb26"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779619108628-AddDropdownOptionsToCustomFields.ts

@@ -0,0 +1,67 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddDropdownOptionsToCustomFields1779619108628
+  implements MigrationInterface
+{
+  public name: string = "AddDropdownOptionsToCustomFields1779619108628";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MonitorCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamMemberCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertCustomField" ADD "dropdownOptions" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamMemberCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MonitorCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentCustomField" DROP COLUMN "dropdownOptions"`,
+    );
+  }
+}

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

@@ -342,6 +342,11 @@ import { DropServiceDependencyTable1779277271302 } from "./1779277271302-DropSer
 import { AddTelemetryRetentionToHostDockerKubernetes1779282769946 } from "./1779282769946-AddTelemetryRetentionToHostDockerKubernetes";
 import { AttachKubernetesAndDockerToIncidentAndAlert1779302536475 } from "./1779302536475-AttachKubernetesAndDockerToIncidentAndAlert";
 import { AttachServiceToIncidentAndAlert1779303924241 } from "./1779303924241-AttachServiceToIncidentAndAlert";
+import { AddAgentVersionToKubernetesDockerHost1779392865146 } from "./1779392865146-AddAgentVersionToKubernetesDockerHost";
+import { AddPerformanceIndexes1779392970424 } from "./1779392970424-AddPerformanceIndexes";
+import { AddFacetsToTableView1779536271671 } from "./1779536271671-AddFacetsToTableView";
+import { AddIsMemberNotifiedIndex1779540427366 } from "./1779540427366-AddIsMemberNotifiedIndex";
+import { AddDropdownOptionsToCustomFields1779619108628 } from "./1779619108628-AddDropdownOptionsToCustomFields";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -687,4 +692,9 @@ export default [
   AddTelemetryRetentionToHostDockerKubernetes1779282769946,
   AttachKubernetesAndDockerToIncidentAndAlert1779302536475,
   AttachServiceToIncidentAndAlert1779303924241,
+  AddAgentVersionToKubernetesDockerHost1779392865146,
+  AddPerformanceIndexes1779392970424,
+  AddFacetsToTableView1779536271671,
+  AddIsMemberNotifiedIndex1779540427366,
+  AddDropdownOptionsToCustomFields1779619108628,
 ];

package/Server/Infrastructure/PostgresDatabase.ts

@@ -82,12 +82,9 @@ export default class Database {
 
   @CaptureSpan()
   public static async checkConnnectionStatus(): Promise<boolean> {
-    // check popstgres connection to see if it is still alive
-
+    // SELECT 1 round-trips a connection without scanning any user table.
     try {
-      const result: any = await this.dataSource?.query(
-        `SELECT COUNT(domain) FROM "AcmeChallenge"`,
-      ); // this is a dummy query to check if the connection is still alive
+      const result: any = await this.dataSource?.query(`SELECT 1`);
 
       if (!result) {
         return false;