@oneuptime/common 12.0.4 → 12.0.5

package/Tests/Server/Services/SeparateIncidentAlertAiSettingsMigration.test.ts

@@ -0,0 +1,194 @@
+import { MigrationName1786101798351 } from "../../../Server/Infrastructure/Postgres/SchemaMigrations/1786101798351-MigrationName";
+import SchemaMigrations from "../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { describe, expect, test } from "@jest/globals";
+import { QueryRunner } from "typeorm";
+
+type QueryRunnerCapture = {
+  runner: QueryRunner;
+  statements: Array<string>;
+};
+
+const makeQueryRunner: () => QueryRunnerCapture = (): QueryRunnerCapture => {
+  const statements: Array<string> = [];
+
+  return {
+    runner: {
+      query: (statement: string): Promise<undefined> => {
+        statements.push(statement);
+        return Promise.resolve(undefined);
+      },
+    } as unknown as QueryRunner,
+    statements,
+  };
+};
+
+const NEW_COLUMNS: Array<string> = [
+  "enableIncidentInstrumentationFixTasks",
+  "enableAlertInstrumentationFixTasks",
+  "enableAutomaticIncidentCodeFixes",
+  "enableAutomaticAlertCodeFixes",
+  "incidentAiDailyAutonomousTokenLimit",
+  "alertAiDailyAutonomousTokenLimit",
+  "incidentAiDailyFixTaskLimit",
+  "alertAiDailyFixTaskLimit",
+  "incidentAiMaxConcurrentInvestigations",
+  "alertAiMaxConcurrentInvestigations",
+];
+
+describe("separate incident and alert AI settings migration", () => {
+  test("adds all ten lane-specific columns before copying existing settings", async () => {
+    const capture: QueryRunnerCapture = makeQueryRunner();
+
+    await new MigrationName1786101798351().up(capture.runner);
+
+    const updateIndex: number = capture.statements.findIndex(
+      (statement: string): boolean => {
+        return statement.startsWith('UPDATE "Project"');
+      },
+    );
+
+    expect(updateIndex).toBe(NEW_COLUMNS.length);
+
+    for (const column of NEW_COLUMNS) {
+      const addIndex: number = capture.statements.findIndex(
+        (statement: string): boolean => {
+          return statement.includes(`ADD "${column}"`);
+        },
+      );
+
+      expect(addIndex).toBeGreaterThanOrEqual(0);
+      expect(addIndex).toBeLessThan(updateIndex);
+    }
+  });
+
+  test("copies every legacy shared value into both lanes", async () => {
+    const capture: QueryRunnerCapture = makeQueryRunner();
+
+    await new MigrationName1786101798351().up(capture.runner);
+
+    const update: string = capture.statements.find((statement: string) => {
+      return statement.startsWith('UPDATE "Project"');
+    })!;
+
+    expect(update).toContain(
+      '"enableIncidentInstrumentationFixTasks" = "enableInstrumentationFixTasks"',
+    );
+    expect(update).toContain(
+      '"enableAlertInstrumentationFixTasks" = "enableInstrumentationFixTasks"',
+    );
+    expect(update).toContain(
+      '"enableAutomaticIncidentCodeFixes" = "enableAutomaticCodeFixes"',
+    );
+    expect(update).toContain(
+      '"enableAutomaticAlertCodeFixes" = "enableAutomaticCodeFixes"',
+    );
+    expect(update).toContain(
+      '"incidentAiDailyAutonomousTokenLimit" = "aiDailyAutonomousTokenLimit"',
+    );
+    expect(update).toContain(
+      '"alertAiDailyAutonomousTokenLimit" = "aiDailyAutonomousTokenLimit"',
+    );
+    expect(update).toContain(
+      '"incidentAiDailyFixTaskLimit" = "aiDailyFixTaskLimit"',
+    );
+    expect(update).toContain(
+      '"alertAiDailyFixTaskLimit" = "aiDailyFixTaskLimit"',
+    );
+    expect(update).toContain(
+      '"incidentAiMaxConcurrentInvestigations" = "aiMaxConcurrentInvestigations"',
+    );
+    expect(update).toContain(
+      '"alertAiMaxConcurrentInvestigations" = "aiMaxConcurrentInvestigations"',
+    );
+  });
+
+  test("drops legacy toggles only after their values are copied", async () => {
+    const capture: QueryRunnerCapture = makeQueryRunner();
+
+    await new MigrationName1786101798351().up(capture.runner);
+
+    const updateIndex: number = capture.statements.findIndex(
+      (statement: string): boolean => {
+        return statement.startsWith('UPDATE "Project"');
+      },
+    );
+
+    for (const legacyToggle of [
+      "enableInstrumentationFixTasks",
+      "enableAutomaticCodeFixes",
+    ]) {
+      const dropIndex: number = capture.statements.findIndex(
+        (statement: string): boolean => {
+          return statement.includes(`DROP COLUMN "${legacyToggle}"`);
+        },
+      );
+
+      expect(dropIndex).toBeGreaterThan(updateIndex);
+    }
+
+    expect(capture.statements.join("\n")).not.toMatch(
+      /DROP COLUMN "ai(DailyAutonomousTokenLimit|DailyFixTaskLimit|MaxConcurrentInvestigations)"/,
+    );
+  });
+
+  test("down migration conservatively merges either enabled lane", async () => {
+    const capture: QueryRunnerCapture = makeQueryRunner();
+
+    await new MigrationName1786101798351().down(capture.runner);
+
+    const updateIndex: number = capture.statements.findIndex(
+      (statement: string): boolean => {
+        return statement.startsWith('UPDATE "Project"');
+      },
+    );
+    const update: string = capture.statements[updateIndex]!;
+
+    expect(update).toContain(
+      '"enableInstrumentationFixTasks" = "enableIncidentInstrumentationFixTasks" OR "enableAlertInstrumentationFixTasks"',
+    );
+    expect(update).toContain(
+      '"enableAutomaticCodeFixes" = "enableAutomaticIncidentCodeFixes" OR "enableAutomaticAlertCodeFixes"',
+    );
+
+    for (const legacyToggle of [
+      "enableInstrumentationFixTasks",
+      "enableAutomaticCodeFixes",
+    ]) {
+      const addIndex: number = capture.statements.findIndex(
+        (statement: string): boolean => {
+          return statement.includes(`ADD "${legacyToggle}"`);
+        },
+      );
+
+      expect(addIndex).toBeGreaterThanOrEqual(0);
+      expect(addIndex).toBeLessThan(updateIndex);
+    }
+  });
+
+  test("down removes exactly the ten lane-specific columns", async () => {
+    const capture: QueryRunnerCapture = makeQueryRunner();
+
+    await new MigrationName1786101798351().down(capture.runner);
+
+    const droppedColumns: Array<string> = capture.statements
+      .map((statement: string): string | undefined => {
+        return statement.match(/DROP COLUMN "([^"]+)"/)?.[1];
+      })
+      .filter((column: string | undefined): column is string => {
+        return Boolean(column);
+      })
+      .sort();
+
+    expect(droppedColumns).toEqual([...NEW_COLUMNS].sort());
+  });
+
+  test("is registered exactly once with its generated timestamp", () => {
+    expect(MigrationName1786101798351.name).toBe("MigrationName1786101798351");
+    expect(SchemaMigrations).toContain(MigrationName1786101798351);
+    expect(
+      SchemaMigrations.filter((migration: { name: string }): boolean => {
+        return migration.name === "MigrationName1786101798351";
+      }),
+    ).toHaveLength(1);
+  });
+});

package/Tests/Server/Utils/AI/AIAlertGating.test.ts

@@ -6,6 +6,7 @@ import AlertService from "../../../../Server/Services/AlertService";
 import AlertSeverityService from "../../../../Server/Services/AlertSeverityService";
 import ProjectService from "../../../../Server/Services/ProjectService";
 import AIRunService from "../../../../Server/Services/AIRunService";
+import QueryHelper from "../../../../Server/Types/Database/QueryHelper";
 import Alert from "../../../../Models/DatabaseModels/Alert";
 import AlertSeverity from "../../../../Models/DatabaseModels/AlertSeverity";
 import Project from "../../../../Models/DatabaseModels/Project";
@@ -20,7 +21,7 @@ import { describe, expect, test, afterEach } from "@jest/globals";
  *     severity);
  *   - per-monitor dedupe window: a monitor already investigated within the
  *     window is not re-investigated;
- *   - per-project concurrency cap in the shared engine.
+ *   - an alert-specific concurrency cap in the shared engine.
  *
  * These tests mock the persistence layer (no Postgres) to lock in the gate
  * decisions and their fail directions: unknown severity PASSES the severity
@@ -217,6 +218,36 @@ describe("AIAlertInvestigationRunner.shouldInvestigateAlert", () => {
     );
   });
 
+  test("the cooldown counts alert investigations only, so incident runs cannot suppress an alert", async () => {
+    const monitorId: ObjectID = ObjectID.generate();
+    const alertSubjectFilter: Record<string, string> = {
+      operator: "alert-not-null",
+    };
+    const incidentSubjectFilter: Record<string, string> = {
+      operator: "incident-null",
+    };
+    jest.spyOn(QueryHelper, "notNull").mockReturnValue(alertSubjectFilter);
+    jest.spyOn(QueryHelper, "isNull").mockReturnValue(incidentSubjectFilter);
+    const countBy: jest.SpyInstance = jest.spyOn(AIRunService, "countBy");
+
+    mockGates({
+      alert: fakeAlert({ severityOrder: 1, monitorId }),
+      topTiers: fakeSeverities([1, 2]),
+      recentRunCount: 0,
+    });
+
+    await AIAlertInvestigationRunner.shouldInvestigateAlert({
+      alertId,
+      projectId,
+    });
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["triggeredByAlertId"]).toBe(alertSubjectFilter);
+    expect(query["triggeredByIncidentId"]).toBe(incidentSubjectFilter);
+  });
+
   test("alerts without a monitor skip the dedupe check entirely", async () => {
     const countBy: jest.SpyInstance = jest.spyOn(AIRunService, "countBy");
 
@@ -299,7 +330,7 @@ describe("AIInvestigationQueue concurrency cap", () => {
     jest.restoreAllMocks();
   });
 
-  test("leaves the run queued when the per-project cap is reached", async () => {
+  test("leaves the run queued when the alert cap is reached", async () => {
     jest
       .spyOn(AIRunService, "countBy")
       .mockResolvedValue(new PositiveNumber(3));
@@ -335,10 +366,12 @@ describe("AIInvestigationQueue concurrency cap", () => {
     expect(claim).not.toHaveBeenCalled();
   });
 
-  test("a per-project cap override of 1 blocks the second concurrent run", async () => {
+  test("an alert cap override of 1 blocks the second concurrent alert run", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
       id: ObjectID.generate(),
-      aiMaxConcurrentInvestigations: 1,
+      aiMaxConcurrentInvestigations: 10,
+      incidentAiMaxConcurrentInvestigations: 10,
+      alertAiMaxConcurrentInvestigations: 1,
     } as unknown as Project);
     jest
       .spyOn(AIRunService, "countBy")