@oneuptime/common 10.4.11 → 10.4.13

package/Models/DatabaseModels/RunbookAgent.ts

@@ -313,7 +313,14 @@ export default class RunbookAgent extends BaseModel {
   public key?: string = undefined;
 
   @ColumnAccessControl({
-    create: [],
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.RunbookAdmin,
+      Permission.RunbookMember,
+      Permission.CreateRunbookAgent,
+    ],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
@@ -369,7 +376,14 @@ export default class RunbookAgent extends BaseModel {
   public lastAlive?: Date = undefined;
 
   @ColumnAccessControl({
-    create: [],
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.RunbookAdmin,
+      Permission.RunbookMember,
+      Permission.CreateRunbookAgent,
+    ],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,

package/Server/EnvironmentConfig.ts

@@ -285,6 +285,22 @@ export const ShouldClickhouseSslEnable: boolean = Boolean(
   ClickhouseTlsCa || (ClickhouseTlsCert && ClickhouseTlsKey),
 );
 
+export const MaxClickhouseConnections: number = parseInt(
+  process.env["CLICKHOUSE_MAX_OPEN_CONNECTIONS"] || "100",
+  10,
+);
+
+/*
+ * Ingest pool size. Falls back to MaxClickhouseConnections so single-knob
+ * setups still work; override only when the ingest pool needs to be sized
+ * independently from the query pool.
+ */
+export const MaxClickhouseIngestConnections: number = parseInt(
+  process.env["CLICKHOUSE_INGEST_MAX_OPEN_CONNECTIONS"] ||
+    String(MaxClickhouseConnections),
+  10,
+);
+
 export const GitSha: string = process.env["GIT_SHA"] || "unknown";
 
 export const AppVersion: string = process.env["APP_VERSION"] || "unknown";

package/Server/Infrastructure/ClickhouseConfig.ts

@@ -9,6 +9,8 @@ import {
   ClickhouseTlsCert,
   ClickhouseTlsKey,
   ClickhouseUsername,
+  MaxClickhouseConnections,
+  MaxClickhouseIngestConnections,
   ShouldClickhouseSslEnable,
 } from "../EnvironmentConfig";
 import Hostname from "../../Types/API/Hostname";
@@ -35,6 +37,13 @@ const options: ClickHouseClientConfigOptions = {
    * aggregation statements provides the hard server-side cap.
    */
   request_timeout: 58_000,
+  /*
+   * @clickhouse/client defaults max_open_connections to 10. Sized for the
+   * query pool (dashboard reads, DDL); ingest writes use a separate pool
+   * (see ingestDataSourceOptions) so a burst of inserts cannot starve
+   * user-facing queries of HTTP sockets.
+   */
+  max_open_connections: MaxClickhouseConnections,
 };
 
 if (ShouldClickhouseSslEnable && ClickhouseTlsCa) {
@@ -58,5 +67,10 @@ if (
 
 export const dataSourceOptions: ClickHouseClientConfigOptions = options;
 
+export const ingestDataSourceOptions: ClickHouseClientConfigOptions = {
+  ...options,
+  max_open_connections: MaxClickhouseIngestConnections,
+};
+
 export const testDataSourceOptions: ClickHouseClientConfigOptions =
   dataSourceOptions;

package/Server/Infrastructure/ClickhouseDatabase.ts

@@ -2,6 +2,7 @@ import logger from "../Utils/Logger";
 import {
   ClickHouseClientConfigOptions,
   dataSourceOptions,
+  ingestDataSourceOptions,
   testDataSourceOptions,
 } from "./ClickhouseConfig";
 import { PingResult, createClient, ClickHouseClient } from "@clickhouse/client";
@@ -18,9 +19,16 @@ export type ClickhouseClient = ClickHouseClient;
 
 export default class ClickhouseDatabase {
   private dataSource!: ClickhouseClient | null;
+  private options: ClickHouseClientConfigOptions;
+
+  public constructor(
+    options: ClickHouseClientConfigOptions = dataSourceOptions,
+  ) {
+    this.options = options;
+  }
 
   public getDatasourceOptions(): ClickHouseClientConfigOptions {
-    return dataSourceOptions;
+    return this.options;
   }
 
   public getTestDatasourceOptions(): ClickHouseClientConfigOptions {
@@ -161,5 +169,14 @@ export default class ClickhouseDatabase {
   }
 }
 
-export const ClickhouseAppInstance: ClickhouseDatabase =
-  new ClickhouseDatabase();
+export const ClickhouseAppInstance: ClickhouseDatabase = new ClickhouseDatabase(
+  dataSourceOptions,
+);
+
+/*
+ * Separate pool for high-volume telemetry inserts. Reads/DDL keep using
+ * ClickhouseAppInstance so dashboard queries are not starved of HTTP
+ * sockets when ingest is bursting.
+ */
+export const ClickhouseIngestInstance: ClickhouseDatabase =
+  new ClickhouseDatabase(ingestDataSourceOptions);

package/Server/Infrastructure/InMemoryTTLCache.ts

@@ -0,0 +1,61 @@
+interface CacheEntry<T> {
+  value: T;
+  expiresAt: number;
+}
+
+/**
+ * Bounded, in-process TTL cache. Entries expire on read after their TTL and the
+ * oldest entry is evicted when capacity is reached (Map preserves insertion
+ * order, which we use as a coarse LRU on writes).
+ *
+ * Each process holds its own copy — there is no cross-process invalidation.
+ * Callers that need stronger consistency should pair the TTL with an explicit
+ * `delete()` on writes to the underlying data.
+ */
+export default class InMemoryTTLCache<T> {
+  private store: Map<string, CacheEntry<T>> = new Map();
+  private maxEntries: number;
+
+  public constructor(maxEntries: number = 10_000) {
+    this.maxEntries = maxEntries;
+  }
+
+  public set(key: string, value: T, ttlMs: number): void {
+    if (this.store.size >= this.maxEntries && !this.store.has(key)) {
+      const oldest: string | undefined = this.store.keys().next().value;
+      if (oldest !== undefined) {
+        this.store.delete(oldest);
+      }
+    }
+    this.store.delete(key);
+    this.store.set(key, { value, expiresAt: Date.now() + ttlMs });
+  }
+
+  public get(key: string): T | undefined {
+    const entry: CacheEntry<T> | undefined = this.store.get(key);
+    if (!entry) {
+      return undefined;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  public has(key: string): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  public delete(key: string): void {
+    this.store.delete(key);
+  }
+
+  public clear(): void {
+    this.store.clear();
+  }
+
+  public size(): number {
+    return this.store.size;
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779302536475-AttachKubernetesAndDockerToIncidentAndAlert.ts

@@ -0,0 +1,253 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AttachKubernetesAndDockerToIncidentAndAlert1779302536475
+  implements MigrationInterface
+{
+  public name: string =
+    "AttachKubernetesAndDockerToIncidentAndAlert1779302536475";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // IncidentKubernetesCluster
+    await queryRunner.query(
+      `CREATE TABLE "IncidentKubernetesCluster" ("incidentId" uuid NOT NULL, "kubernetesClusterId" uuid NOT NULL, CONSTRAINT "PK_0706004605b87701df3fb2fc4fb" PRIMARY KEY ("incidentId", "kubernetesClusterId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_4d49468cbea4ece4fe7e2ecf3f" ON "IncidentKubernetesCluster" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_cb313f51853d6178c1ea498405" ON "IncidentKubernetesCluster" ("kubernetesClusterId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesCluster" ADD CONSTRAINT "FK_4d49468cbea4ece4fe7e2ecf3f8" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesCluster" ADD CONSTRAINT "FK_cb313f51853d6178c1ea498405e" FOREIGN KEY ("kubernetesClusterId") REFERENCES "KubernetesCluster"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // IncidentKubernetesResource
+    await queryRunner.query(
+      `CREATE TABLE "IncidentKubernetesResource" ("incidentId" uuid NOT NULL, "kubernetesResourceId" uuid NOT NULL, CONSTRAINT "PK_2d7d43459ccef0edddd433dab0f" PRIMARY KEY ("incidentId", "kubernetesResourceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_706dad5f9b04e57516310bb107" ON "IncidentKubernetesResource" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_bd41e6a5b7368685534190f8e8" ON "IncidentKubernetesResource" ("kubernetesResourceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesResource" ADD CONSTRAINT "FK_706dad5f9b04e57516310bb1076" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesResource" ADD CONSTRAINT "FK_bd41e6a5b7368685534190f8e85" FOREIGN KEY ("kubernetesResourceId") REFERENCES "KubernetesResource"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // IncidentKubernetesContainer
+    await queryRunner.query(
+      `CREATE TABLE "IncidentKubernetesContainer" ("incidentId" uuid NOT NULL, "kubernetesContainerId" uuid NOT NULL, CONSTRAINT "PK_96c823347cee097c4c99d60d472" PRIMARY KEY ("incidentId", "kubernetesContainerId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_318c277a133ab782087eee5a93" ON "IncidentKubernetesContainer" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_411d29efab26561877b148bb21" ON "IncidentKubernetesContainer" ("kubernetesContainerId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesContainer" ADD CONSTRAINT "FK_318c277a133ab782087eee5a93b" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesContainer" ADD CONSTRAINT "FK_411d29efab26561877b148bb218" FOREIGN KEY ("kubernetesContainerId") REFERENCES "KubernetesContainer"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // IncidentDockerHost
+    await queryRunner.query(
+      `CREATE TABLE "IncidentDockerHost" ("incidentId" uuid NOT NULL, "dockerHostId" uuid NOT NULL, CONSTRAINT "PK_56a970e60a6af0ae3bc03952a82" PRIMARY KEY ("incidentId", "dockerHostId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_364b7b272015813b8ee02314c4" ON "IncidentDockerHost" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9761ce8eb83f4d63d7fef00a55" ON "IncidentDockerHost" ("dockerHostId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerHost" ADD CONSTRAINT "FK_364b7b272015813b8ee02314c45" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerHost" ADD CONSTRAINT "FK_9761ce8eb83f4d63d7fef00a55c" FOREIGN KEY ("dockerHostId") REFERENCES "DockerHost"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // IncidentDockerResource
+    await queryRunner.query(
+      `CREATE TABLE "IncidentDockerResource" ("incidentId" uuid NOT NULL, "dockerResourceId" uuid NOT NULL, CONSTRAINT "PK_5c1f59bafc8278da53767c2aeae" PRIMARY KEY ("incidentId", "dockerResourceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_5a1cf0cb50fec5135cfd715e2c" ON "IncidentDockerResource" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c90832cd0bce96661ae3e3652c" ON "IncidentDockerResource" ("dockerResourceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerResource" ADD CONSTRAINT "FK_5a1cf0cb50fec5135cfd715e2cb" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerResource" ADD CONSTRAINT "FK_c90832cd0bce96661ae3e3652cc" FOREIGN KEY ("dockerResourceId") REFERENCES "DockerResource"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // AlertKubernetesCluster
+    await queryRunner.query(
+      `CREATE TABLE "AlertKubernetesCluster" ("alertId" uuid NOT NULL, "kubernetesClusterId" uuid NOT NULL, CONSTRAINT "PK_36951c4b963d30a51d49db2f185" PRIMARY KEY ("alertId", "kubernetesClusterId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9c59dd1fbaa2623c55147588fa" ON "AlertKubernetesCluster" ("alertId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b880dd9641b488d37e9c4dbc96" ON "AlertKubernetesCluster" ("kubernetesClusterId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesCluster" ADD CONSTRAINT "FK_9c59dd1fbaa2623c55147588fa4" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesCluster" ADD CONSTRAINT "FK_b880dd9641b488d37e9c4dbc967" FOREIGN KEY ("kubernetesClusterId") REFERENCES "KubernetesCluster"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // AlertKubernetesResource
+    await queryRunner.query(
+      `CREATE TABLE "AlertKubernetesResource" ("alertId" uuid NOT NULL, "kubernetesResourceId" uuid NOT NULL, CONSTRAINT "PK_55c136562d0b3ca986eedd20344" PRIMARY KEY ("alertId", "kubernetesResourceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_09847045f3b90d01b5d5116a27" ON "AlertKubernetesResource" ("alertId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_04479f7cd61764c417284364e4" ON "AlertKubernetesResource" ("kubernetesResourceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesResource" ADD CONSTRAINT "FK_09847045f3b90d01b5d5116a278" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesResource" ADD CONSTRAINT "FK_04479f7cd61764c417284364e49" FOREIGN KEY ("kubernetesResourceId") REFERENCES "KubernetesResource"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // AlertKubernetesContainer
+    await queryRunner.query(
+      `CREATE TABLE "AlertKubernetesContainer" ("alertId" uuid NOT NULL, "kubernetesContainerId" uuid NOT NULL, CONSTRAINT "PK_5004da87e6cee38c2cdce1c015b" PRIMARY KEY ("alertId", "kubernetesContainerId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e5e3b19d56842d98ad736f2451" ON "AlertKubernetesContainer" ("alertId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_cc7bd03e0d9fec67856319959b" ON "AlertKubernetesContainer" ("kubernetesContainerId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesContainer" ADD CONSTRAINT "FK_e5e3b19d56842d98ad736f2451e" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesContainer" ADD CONSTRAINT "FK_cc7bd03e0d9fec67856319959be" FOREIGN KEY ("kubernetesContainerId") REFERENCES "KubernetesContainer"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // AlertDockerHost
+    await queryRunner.query(
+      `CREATE TABLE "AlertDockerHost" ("alertId" uuid NOT NULL, "dockerHostId" uuid NOT NULL, CONSTRAINT "PK_12c730ea1126a0cccde73ce819e" PRIMARY KEY ("alertId", "dockerHostId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2b33c4643132be69e65dc48653" ON "AlertDockerHost" ("alertId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e98f39fecd1bc955015882ca34" ON "AlertDockerHost" ("dockerHostId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerHost" ADD CONSTRAINT "FK_2b33c4643132be69e65dc48653c" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerHost" ADD CONSTRAINT "FK_e98f39fecd1bc955015882ca34b" FOREIGN KEY ("dockerHostId") REFERENCES "DockerHost"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // AlertDockerResource
+    await queryRunner.query(
+      `CREATE TABLE "AlertDockerResource" ("alertId" uuid NOT NULL, "dockerResourceId" uuid NOT NULL, CONSTRAINT "PK_60dbce6b63a1cac67178bbb3998" PRIMARY KEY ("alertId", "dockerResourceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8843cfc9ef7118e39a40d32548" ON "AlertDockerResource" ("alertId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c781b3411915ba016ea3fc30fd" ON "AlertDockerResource" ("dockerResourceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerResource" ADD CONSTRAINT "FK_8843cfc9ef7118e39a40d325489" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerResource" ADD CONSTRAINT "FK_c781b3411915ba016ea3fc30fd3" FOREIGN KEY ("dockerResourceId") REFERENCES "DockerResource"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerResource" DROP CONSTRAINT "FK_c781b3411915ba016ea3fc30fd3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerResource" DROP CONSTRAINT "FK_8843cfc9ef7118e39a40d325489"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerHost" DROP CONSTRAINT "FK_e98f39fecd1bc955015882ca34b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertDockerHost" DROP CONSTRAINT "FK_2b33c4643132be69e65dc48653c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesContainer" DROP CONSTRAINT "FK_cc7bd03e0d9fec67856319959be"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesContainer" DROP CONSTRAINT "FK_e5e3b19d56842d98ad736f2451e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesResource" DROP CONSTRAINT "FK_04479f7cd61764c417284364e49"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesResource" DROP CONSTRAINT "FK_09847045f3b90d01b5d5116a278"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesCluster" DROP CONSTRAINT "FK_b880dd9641b488d37e9c4dbc967"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertKubernetesCluster" DROP CONSTRAINT "FK_9c59dd1fbaa2623c55147588fa4"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerResource" DROP CONSTRAINT "FK_c90832cd0bce96661ae3e3652cc"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerResource" DROP CONSTRAINT "FK_5a1cf0cb50fec5135cfd715e2cb"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerHost" DROP CONSTRAINT "FK_9761ce8eb83f4d63d7fef00a55c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentDockerHost" DROP CONSTRAINT "FK_364b7b272015813b8ee02314c45"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesContainer" DROP CONSTRAINT "FK_411d29efab26561877b148bb218"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesContainer" DROP CONSTRAINT "FK_318c277a133ab782087eee5a93b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesResource" DROP CONSTRAINT "FK_bd41e6a5b7368685534190f8e85"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesResource" DROP CONSTRAINT "FK_706dad5f9b04e57516310bb1076"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesCluster" DROP CONSTRAINT "FK_cb313f51853d6178c1ea498405e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentKubernetesCluster" DROP CONSTRAINT "FK_4d49468cbea4ece4fe7e2ecf3f8"`,
+    );
+    await queryRunner.query(`DROP TABLE "AlertDockerResource"`);
+    await queryRunner.query(`DROP TABLE "AlertDockerHost"`);
+    await queryRunner.query(`DROP TABLE "AlertKubernetesContainer"`);
+    await queryRunner.query(`DROP TABLE "AlertKubernetesResource"`);
+    await queryRunner.query(`DROP TABLE "AlertKubernetesCluster"`);
+    await queryRunner.query(`DROP TABLE "IncidentDockerResource"`);
+    await queryRunner.query(`DROP TABLE "IncidentDockerHost"`);
+    await queryRunner.query(`DROP TABLE "IncidentKubernetesContainer"`);
+    await queryRunner.query(`DROP TABLE "IncidentKubernetesResource"`);
+    await queryRunner.query(`DROP TABLE "IncidentKubernetesCluster"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779303924241-AttachServiceToIncidentAndAlert.ts

@@ -0,0 +1,60 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AttachServiceToIncidentAndAlert1779303924241
+  implements MigrationInterface
+{
+  public name: string = "AttachServiceToIncidentAndAlert1779303924241";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // IncidentService
+    await queryRunner.query(
+      `CREATE TABLE "IncidentService" ("incidentId" uuid NOT NULL, "serviceId" uuid NOT NULL, CONSTRAINT "PK_f4278c4ad966e1388f6aa832b98" PRIMARY KEY ("incidentId", "serviceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9b8061de368e0c38bf78fc1412" ON "IncidentService" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_780433e4b5ce2df00b7dc2b30b" ON "IncidentService" ("serviceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentService" ADD CONSTRAINT "FK_9b8061de368e0c38bf78fc1412d" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentService" ADD CONSTRAINT "FK_780433e4b5ce2df00b7dc2b30b6" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // AlertService
+    await queryRunner.query(
+      `CREATE TABLE "AlertService" ("alertId" uuid NOT NULL, "serviceId" uuid NOT NULL, CONSTRAINT "PK_eb1648d9ffb96bf6c38d90c4293" PRIMARY KEY ("alertId", "serviceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_f250e1b41b406c65d007cc08a9" ON "AlertService" ("alertId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c93eaf768fb41804783e246b12" ON "AlertService" ("serviceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertService" ADD CONSTRAINT "FK_f250e1b41b406c65d007cc08a9c" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertService" ADD CONSTRAINT "FK_c93eaf768fb41804783e246b129" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AlertService" DROP CONSTRAINT "FK_c93eaf768fb41804783e246b129"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertService" DROP CONSTRAINT "FK_f250e1b41b406c65d007cc08a9c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentService" DROP CONSTRAINT "FK_780433e4b5ce2df00b7dc2b30b6"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentService" DROP CONSTRAINT "FK_9b8061de368e0c38bf78fc1412d"`,
+    );
+    await queryRunner.query(`DROP TABLE "AlertService"`);
+    await queryRunner.query(`DROP TABLE "IncidentService"`);
+  }
+}

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

@@ -340,6 +340,8 @@ import { IncreaseSmtpUsernameLength1779125489830 } from "./1779125489830-Increas
 import { AddTelemetryRetentionConfig1779199346010 } from "./1779199346010-AddTelemetryRetentionConfig";
 import { DropServiceDependencyTable1779277271302 } from "./1779277271302-DropServiceDependencyTable";
 import { AddTelemetryRetentionToHostDockerKubernetes1779282769946 } from "./1779282769946-AddTelemetryRetentionToHostDockerKubernetes";
+import { AttachKubernetesAndDockerToIncidentAndAlert1779302536475 } from "./1779302536475-AttachKubernetesAndDockerToIncidentAndAlert";
+import { AttachServiceToIncidentAndAlert1779303924241 } from "./1779303924241-AttachServiceToIncidentAndAlert";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -683,4 +685,6 @@ export default [
   AddTelemetryRetentionConfig1779199346010,
   DropServiceDependencyTable1779277271302,
   AddTelemetryRetentionToHostDockerKubernetes1779282769946,
+  AttachKubernetesAndDockerToIncidentAndAlert1779302536475,
+  AttachServiceToIncidentAndAlert1779303924241,
 ];

package/Server/Middleware/TelemetryIngest.ts

@@ -7,7 +7,6 @@ import {
   NextFunction,
 } from "../../Server/Utils/Express";
 import TelemetryIngestionKeyService from "../../Server/Services/TelemetryIngestionKeyService";
-import TelemetryIngestionKey from "../../Models/DatabaseModels/TelemetryIngestionKey";
 import Response from "../Utils/Response";
 import logger, { getLogAttributesFromRequest } from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -65,45 +64,14 @@ export default class TelemetryIngest {
         throw new BadRequestException("Missing header: x-oneuptime-token");
       }
 
-      let projectId: ObjectID | undefined = undefined;
-
-      const token: TelemetryIngestionKey | null =
-        await TelemetryIngestionKeyService.findOneBy({
-          query: {
-            secretKey: new ObjectID(oneuptimeToken?.toString() || ""),
-          },
-          select: {
-            projectId: true,
-          },
-          props: {
-            isRoot: true,
-          },
-        });
-
-      if (!token) {
-        logger.error(
-          "Invalid service token: " + oneuptimeToken,
-          getLogAttributesFromRequest(req as any),
+      const projectId: ObjectID | null =
+        await TelemetryIngestionKeyService.getProjectIdFromSecretKey(
+          oneuptimeToken.toString(),
         );
 
-        if (isOpenTelemetryAPI) {
-          /*
-           * then accept the response and return success.
-           * do not return error because it causes Otel to retry the request.
-           */
-          return Response.sendEmptySuccessResponse(req, res);
-        }
-
-        throw new BadRequestException(
-          "Invalid service token: " + oneuptimeToken,
-        );
-      }
-
-      projectId = token.projectId as ObjectID;
-
       if (!projectId) {
         logger.error(
-          "Project ID not found for service token: " + oneuptimeToken,
+          "Invalid service token: " + oneuptimeToken,
           getLogAttributesFromRequest(req as any),
         );
 
@@ -116,11 +84,11 @@ export default class TelemetryIngest {
         }
 
         throw new BadRequestException(
-          "Project ID not found for service token: " + oneuptimeToken,
+          "Invalid service token: " + oneuptimeToken,
         );
       }
 
-      (req as TelemetryRequest).projectId = projectId as ObjectID;
+      (req as TelemetryRequest).projectId = projectId;
 
       // Tag span with project context for telemetry ingestion observability
       SpanUtil.addAttributesToCurrentSpan({

package/Server/Middleware/UserAuthorization.ts

@@ -277,7 +277,6 @@ export default class UserMiddleware {
             req,
             tenantId,
             userId: new ObjectID(userId),
-            isGlobalLogin: oneuptimeRequest.userAuthorization.isGlobalLogin,
           });
 
         if (userTenantAccessPermission) {
@@ -466,9 +465,8 @@ export default class UserMiddleware {
     req: ExpressRequest;
     tenantId: ObjectID;
     userId: ObjectID;
-    isGlobalLogin: boolean;
   }): Promise<UserTenantAccessPermission | null> {
-    const { req, tenantId, userId, isGlobalLogin } = data;
+    const { req, tenantId, userId } = data;
 
     const project: Project | null = await ProjectService.findOneById({
       id: tenantId,
@@ -484,14 +482,6 @@ export default class UserMiddleware {
       throw new TenantNotFoundException("Invalid tenantId");
     }
 
-    if (!isGlobalLogin) {
-      if (!UserMiddleware.doesSsoTokenForProjectExist(req, tenantId, userId)) {
-        throw new NotAuthenticatedException(
-          "This project requires OneUptime authentication. Please login to access this project.",
-        );
-      }
-    }
-
     if (
       project.requireSsoForLogin &&
       !UserMiddleware.doesSsoTokenForProjectExist(req, tenantId, userId)