@oneuptime/common 12.0.4 → 12.0.6

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

@@ -4,6 +4,7 @@ import FixRunBudget, {
 } from "../../../../Server/Utils/AI/CodeFix/FixRunBudget";
 import ProjectService from "../../../../Server/Services/ProjectService";
 import AIRunService from "../../../../Server/Services/AIRunService";
+import QueryHelper from "../../../../Server/Types/Database/QueryHelper";
 import Project from "../../../../Models/DatabaseModels/Project";
 import AIRunType from "../../../../Types/AI/AIRunType";
 import BadDataException from "../../../../Types/Exception/BadDataException";
@@ -12,11 +13,11 @@ import PositiveNumber from "../../../../Types/PositiveNumber";
 import { describe, expect, test, afterEach } from "@jest/globals";
 
 /*
- * The per-project daily fix-run budget (G11 guardrail): every CodeFix
- * AIRun counts against Project.aiDailyFixTaskLimit per UTC day. Unlike the
- * token budget, an UNSET limit is NOT unlimited — fix runs open pull
+ * The per-project daily fix-run budget (G11 guardrail): incident, alert and
+ * subjectless CodeFix AIRuns each count only against their own lane. Unlike
+ * the token budget, an UNSET limit is NOT unlimited — fix runs open pull
  * requests on customer repositories, so the default cap applies. 0 pauses
- * fix tasks entirely (the same kill-switch semantics as the token budget).
+ * that lane entirely (the same kill-switch semantics as the token budget).
  */
 
 const projectId: ObjectID = ObjectID.generate();
@@ -92,24 +93,37 @@ describe("FixRunBudget.evaluate (pure decision)", () => {
 });
 
 describe("FixRunBudget.describeRejection", () => {
-  test("paused rejection names the setting and the 0 value", () => {
+  test("paused incident rejection names the incident setting and destination", () => {
     const message: string = FixRunBudget.describeRejection(
       FixRunBudget.evaluate({ configuredLimit: 0, runsToday: 0 }),
+      { incidentId: ObjectID.generate() },
     );
 
-    expect(message).toMatch(/Daily AI Fix Task Limit/);
+    expect(message).toMatch(/Daily Incident AI Fix Task Limit/);
+    expect(message).toMatch(/Incidents > AI > Investigation/);
     expect(message).toMatch(/0/);
   });
 
-  test("over-budget rejection names the counts, the setting and the default", () => {
+  test("over-budget alert rejection names the alert setting and destination", () => {
     const message: string = FixRunBudget.describeRejection(
       FixRunBudget.evaluate({ configuredLimit: 10, runsToday: 10 }),
+      { alertId: ObjectID.generate() },
     );
 
     expect(message).toMatch(/10 of 10/);
-    expect(message).toMatch(/Daily AI Fix Task Limit/);
+    expect(message).toMatch(/Daily Alert AI Fix Task Limit/);
+    expect(message).toMatch(/Alerts > AI > Investigation/);
     expect(message).toMatch(new RegExp(String(DEFAULT_DAILY_FIX_RUN_LIMIT)));
   });
+
+  test("subjectless rejection points to the always-visible AI Guardrails page", () => {
+    const message: string = FixRunBudget.describeRejection(
+      FixRunBudget.evaluate({ configuredLimit: 0, runsToday: 0 }),
+    );
+
+    expect(message).toMatch(/Daily Other AI Fix Task Limit/);
+    expect(message).toMatch(/Project Settings > AI > AI Guardrails/);
+  });
 });
 
 describe("FixRunBudget.getBudgetStatus (IO wiring)", () => {
@@ -117,12 +131,46 @@ describe("FixRunBudget.getBudgetStatus (IO wiring)", () => {
     jest.restoreAllMocks();
   });
 
-  test("counts the project's CodeFix runs created since UTC midnight", async () => {
-    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
-      id: projectId,
-      aiDailyFixTaskLimit: 10,
-    } as unknown as Project);
+  function mockSubjectOperators(): {
+    isNull: Record<string, string>;
+    notNull: Record<string, string>;
+  } {
+    const isNull: Record<string, string> = { operator: "is-null" };
+    const notNull: Record<string, string> = { operator: "not-null" };
+
+    jest.spyOn(QueryHelper, "isNull").mockReturnValue(isNull);
+    jest.spyOn(QueryHelper, "notNull").mockReturnValue(notNull);
 
+    return { isNull, notNull };
+  }
+
+  test("rejects a run carrying both subject types before reading project settings", async () => {
+    const findProject: jest.SpyInstance = jest.spyOn(
+      ProjectService,
+      "findOneById",
+    );
+
+    await expect(
+      FixRunBudget.getBudgetStatus(projectId, {
+        incidentId: ObjectID.generate(),
+        alertId: ObjectID.generate(),
+      }),
+    ).rejects.toThrow(/both an incident and an alert/);
+
+    expect(findProject).not.toHaveBeenCalled();
+  });
+
+  test("subjectless callers retain the fallback limit and count only subjectless CodeFix runs", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 10,
+        incidentAiDailyFixTaskLimit: 1,
+        alertAiDailyFixTaskLimit: 2,
+      } as unknown as Project);
     const countBy: jest.SpyInstance = jest
       .spyOn(AIRunService, "countBy")
       .mockResolvedValue(new PositiveNumber(4));
@@ -136,44 +184,180 @@ describe("FixRunBudget.getBudgetStatus (IO wiring)", () => {
       paused: false,
       runsToday: 4,
     });
+    expect(findProject).toHaveBeenCalledWith(
+      expect.objectContaining({ select: { aiDailyFixTaskLimit: true } }),
+    );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["projectId"]).toBe(projectId);
+    expect(query["runType"]).toBe(AIRunType.CodeFix);
+    expect(query["triggeredByIncidentId"]).toBe(operators.isNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.isNull);
+    // createdAt >= UTC midnight rides in a QueryHelper find operator.
+    expect(query["createdAt"]).toBeDefined();
+  });
+
+  test("an explicitly empty subject from SubjectCodeFixRun also stays in the subjectless lane", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 3,
+        incidentAiDailyFixTaskLimit: 0,
+        alertAiDailyFixTaskLimit: 0,
+      } as unknown as Project);
+    const countBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(2));
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { incidentId: undefined, alertId: undefined },
+    );
+
+    expect(decision.limit).toBe(3);
+    expect(decision.allowed).toBe(true);
+    expect(findProject).toHaveBeenCalledWith(
+      expect.objectContaining({ select: { aiDailyFixTaskLimit: true } }),
+    );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["triggeredByIncidentId"]).toBe(operators.isNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.isNull);
+  });
+
+  test("incident callers select the incident limit and count only incident CodeFix runs", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 99,
+        incidentAiDailyFixTaskLimit: 5,
+        alertAiDailyFixTaskLimit: 1,
+      } as unknown as Project);
+    const countBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(4));
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { incidentId: ObjectID.generate() },
+    );
 
-    expect(countBy).toHaveBeenCalledWith(
+    expect(decision).toEqual({
+      allowed: true,
+      limit: 5,
+      paused: false,
+      runsToday: 4,
+    });
+    expect(findProject).toHaveBeenCalledWith(
       expect.objectContaining({
-        query: expect.objectContaining({
-          projectId,
-          runType: AIRunType.CodeFix,
-          // createdAt >= UTC midnight rides in a QueryHelper find operator.
-          createdAt: expect.anything(),
-        }),
-        props: expect.objectContaining({ isRoot: true }),
+        select: { incidentAiDailyFixTaskLimit: true },
       }),
     );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["runType"]).toBe(AIRunType.CodeFix);
+    expect(query["triggeredByIncidentId"]).toBe(operators.notNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.isNull);
   });
 
-  test("a paused project (limit 0) short-circuits without the count query", async () => {
+  test("alert callers select the alert limit and count only alert CodeFix runs", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 99,
+        incidentAiDailyFixTaskLimit: 1,
+        alertAiDailyFixTaskLimit: 7,
+      } as unknown as Project);
+    const countBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(6));
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { alertId: ObjectID.generate() },
+    );
+
+    expect(decision).toEqual({
+      allowed: true,
+      limit: 7,
+      paused: false,
+      runsToday: 6,
+    });
+    expect(findProject).toHaveBeenCalledWith(
+      expect.objectContaining({ select: { alertAiDailyFixTaskLimit: true } }),
+    );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["runType"]).toBe(AIRunType.CodeFix);
+    expect(query["triggeredByIncidentId"]).toBe(operators.isNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.notNull);
+  });
+
+  test("pausing the incident lane short-circuits without counting another lane", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
       id: projectId,
-      aiDailyFixTaskLimit: 0,
+      aiDailyFixTaskLimit: 50,
+      incidentAiDailyFixTaskLimit: 0,
+      alertAiDailyFixTaskLimit: 50,
     } as unknown as Project);
+    const countBy: jest.SpyInstance = jest.spyOn(AIRunService, "countBy");
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { incidentId: ObjectID.generate() },
+    );
+
+    expect(decision.allowed).toBe(false);
+    expect(decision.paused).toBe(true);
+    expect(countBy).not.toHaveBeenCalled();
+  });
 
+  test("pausing the alert lane short-circuits without counting another lane", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
+      id: projectId,
+      aiDailyFixTaskLimit: 50,
+      incidentAiDailyFixTaskLimit: 50,
+      alertAiDailyFixTaskLimit: 0,
+    } as unknown as Project);
     const countBy: jest.SpyInstance = jest.spyOn(AIRunService, "countBy");
 
-    const decision: FixRunBudgetDecision =
-      await FixRunBudget.getBudgetStatus(projectId);
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { alertId: ObjectID.generate() },
+    );
 
     expect(decision.allowed).toBe(false);
     expect(decision.paused).toBe(true);
     expect(countBy).not.toHaveBeenCalled();
   });
 
-  test("a missing project row falls back to the default cap (fail-safe, not fail-open)", async () => {
+  test("a missing project row uses the default cap in the requested lane (fail-safe, not fail-open)", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue(null);
     jest
       .spyOn(AIRunService, "countBy")
       .mockResolvedValue(new PositiveNumber(DEFAULT_DAILY_FIX_RUN_LIMIT));
 
-    const decision: FixRunBudgetDecision =
-      await FixRunBudget.getBudgetStatus(projectId);
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { alertId: ObjectID.generate() },
+    );
 
     expect(decision.limit).toBe(DEFAULT_DAILY_FIX_RUN_LIMIT);
     expect(decision.allowed).toBe(false);
@@ -199,7 +383,7 @@ describe("FixRunBudget.assertWithinBudget", () => {
     ).resolves.toBeUndefined();
   });
 
-  test("over budget throws a BadDataException naming the setting", async () => {
+  test("over budget throws a BadDataException naming the subjectless setting", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
       id: projectId,
       aiDailyFixTaskLimit: 5,
@@ -212,7 +396,7 @@ describe("FixRunBudget.assertWithinBudget", () => {
       BadDataException,
     );
     await expect(FixRunBudget.assertWithinBudget(projectId)).rejects.toThrow(
-      /Daily AI Fix Task Limit/,
+      /Daily Other AI Fix Task Limit/,
     );
   });
 });

package/Tests/Server/Utils/AI/Insights/ExceptionSpikeDetector.test.ts

@@ -208,8 +208,13 @@ describe("ExceptionSpikeDetector.detect (IO wiring)", () => {
       `exception-spike:${exceptionId.toString()}`,
     );
     expect(candidate.severity).toBe(AIInsightSeverity.High);
+    /*
+     * Type AND message: the type alone collides across findings (a service
+     * whose instrumentation types every failure by HTTP status renders a wall
+     * of identical rows).
+     */
     expect(candidate.title).toBe(
-      "Exception spike: ConnectionError at 50.0x normal rate in payments",
+      "Exception spike: ConnectionError: connection reset by peer at 50.0x normal rate in payments",
     );
     expect(candidate.evidence.exception).toEqual(
       expect.objectContaining({

package/Tests/Server/Utils/AI/Insights/InsightStore.test.ts

@@ -1,6 +1,7 @@
 import InsightStore, {
   DISMISSED_COOLDOWN_DAYS,
   MAX_NEW_INSIGHTS_PER_PROJECT_PER_SCAN,
+  RESOLVED_COOLDOWN_HOURS,
   UpsertCandidatesResult,
 } from "../../../../../Server/Utils/AI/SRE/Insights/InsightStore";
 import { InsightCandidate } from "../../../../../Server/Utils/AI/SRE/Insights/Types";
@@ -46,12 +47,14 @@ function fakeExisting(overrides?: {
   status?: AIInsightStatus;
   occurrenceCount?: number;
   humanVerdictAt?: Date | undefined;
+  lastSeenAt?: Date | undefined;
 }): AIInsight {
   return {
     id: ObjectID.generate(),
     status: overrides?.status ?? AIInsightStatus.Detected,
     occurrenceCount: overrides?.occurrenceCount ?? 2,
     humanVerdictAt: overrides?.humanVerdictAt,
+    lastSeenAt: overrides?.lastSeenAt,
   } as unknown as AIInsight;
 }
 
@@ -166,7 +169,7 @@ describe("InsightStore.upsertCandidates — dedupe matrix", () => {
     [AIInsightStatus.ActionRequired],
     [AIInsightStatus.FixOpened],
   ])(
-    "existing %s insight → REFRESH: lastSeenAt, occurrenceCount+1, evidence/detail/severity updated — and status is NEVER touched",
+    "existing %s insight → REFRESH: lastSeenAt, occurrenceCount+1, title/evidence/detail/severity updated — and status is NEVER touched",
     async (status: AIInsightStatus) => {
       const existing: AIInsight = fakeExisting({
         status,
@@ -179,7 +182,17 @@ describe("InsightStore.upsertCandidates — dedupe matrix", () => {
       const result: UpsertCandidatesResult =
         await InsightStore.upsertCandidates({
           projectId,
-          candidates: [makeCandidate({ severity: AIInsightSeverity.High })],
+          candidates: [
+            makeCandidate({
+              severity: AIInsightSeverity.High,
+              /*
+               * Detectors put live numbers in the title (a spike multiplier,
+               * a latency factor). A title frozen at creation would show
+               * "5.2x" next to a High severity and a 12x detail body.
+               */
+              title: "New exception: NullPointerException in checkout (12.0x)",
+            }),
+          ],
           now,
         });
 
@@ -195,6 +208,7 @@ describe("InsightStore.upsertCandidates — dedupe matrix", () => {
             lastSeenAt: now,
             occurrenceCount: 5,
             severity: AIInsightSeverity.High,
+            title: "New exception: NullPointerException in checkout (12.0x)",
             detailMarkdown: "**3 occurrences** in the last 24 hours.",
             evidence: { exception: { recentOccurrenceCount: 3 } },
           }),
@@ -317,8 +331,65 @@ describe("InsightStore.upsertCandidates — dedupe matrix", () => {
     expect(result.suppressed).toBe(1);
   });
 
-  test("existing Resolved insight → CREATE new: a resolved issue that reappears is a regression", async () => {
-    mockFindOneBy(fakeExisting({ status: AIInsightStatus.Resolved }));
+  /*
+   * Resolve has to stick. Detectors emit on a standing condition, not on an
+   * event — NewException re-emits an unchanged candidate on all ~96 ticks of
+   * its 24h window — so without a cooldown a resolved insight was re-filed
+   * byte-identical 15 minutes later, with its own triage run, every time.
+   */
+  test("existing Resolved insight within the cooldown → suppress, not a byte-identical re-file", async () => {
+    mockFindOneBy(
+      fakeExisting({
+        status: AIInsightStatus.Resolved,
+        humanVerdictAt: new Date(now.getTime() - 15 * 60 * 1000),
+      }),
+    );
+    const create: jest.SpyInstance = mockCreate();
+    const update: jest.SpyInstance = mockUpdateOneById();
+
+    const result: UpsertCandidatesResult = await InsightStore.upsertCandidates({
+      projectId,
+      candidates: [makeCandidate()],
+      now,
+    });
+
+    expect(create).not.toHaveBeenCalled();
+    expect(update).not.toHaveBeenCalled();
+    expect(result.suppressed).toBe(1);
+    expect(result.created).toHaveLength(0);
+    expect(result.refreshed).toBe(0);
+  });
+
+  test("resolve cooldown boundary: exactly RESOLVED_COOLDOWN_HOURS old still suppresses (inclusive)", async () => {
+    mockFindOneBy(
+      fakeExisting({
+        status: AIInsightStatus.Resolved,
+        humanVerdictAt: new Date(
+          now.getTime() - RESOLVED_COOLDOWN_HOURS * 60 * 60 * 1000,
+        ),
+      }),
+    );
+    const create: jest.SpyInstance = mockCreate();
+
+    const result: UpsertCandidatesResult = await InsightStore.upsertCandidates({
+      projectId,
+      candidates: [makeCandidate()],
+      now,
+    });
+
+    expect(create).not.toHaveBeenCalled();
+    expect(result.suppressed).toBe(1);
+  });
+
+  test("resolved past the cooldown → CREATE new: a resolved issue that comes back IS a regression", async () => {
+    mockFindOneBy(
+      fakeExisting({
+        status: AIInsightStatus.Resolved,
+        humanVerdictAt: new Date(
+          now.getTime() - (RESOLVED_COOLDOWN_HOURS * 60 * 60 * 1000 + 1),
+        ),
+      }),
+    );
     const create: jest.SpyInstance = mockCreate();
     const update: jest.SpyInstance = mockUpdateOneById();
 
@@ -333,6 +404,52 @@ describe("InsightStore.upsertCandidates — dedupe matrix", () => {
     expect(result.created).toHaveLength(1);
     expect(result.refreshed).toBe(0);
   });
+
+  /*
+   * resolveInsight leaves an existing verdict alone, so a Confirm-then-Resolve
+   * leaves humanVerdictAt pinned to the CONFIRM. lastSeenAt is the honest
+   * fallback: refreshes stop the instant a row goes terminal, so it is the
+   * last tick before the human closed it — never later than the close.
+   */
+  test("no verdict timestamp: the cooldown falls back to lastSeenAt", async () => {
+    mockFindOneBy(
+      fakeExisting({
+        status: AIInsightStatus.Resolved,
+        humanVerdictAt: undefined,
+        lastSeenAt: new Date(now.getTime() - 60 * 60 * 1000),
+      }),
+    );
+    const create: jest.SpyInstance = mockCreate();
+
+    const result: UpsertCandidatesResult = await InsightStore.upsertCandidates({
+      projectId,
+      candidates: [makeCandidate()],
+      now,
+    });
+
+    expect(create).not.toHaveBeenCalled();
+    expect(result.suppressed).toBe(1);
+  });
+
+  test("an undateable terminal row suppresses — never re-file what we cannot date", async () => {
+    mockFindOneBy(
+      fakeExisting({
+        status: AIInsightStatus.Resolved,
+        humanVerdictAt: undefined,
+        lastSeenAt: undefined,
+      }),
+    );
+    const create: jest.SpyInstance = mockCreate();
+
+    const result: UpsertCandidatesResult = await InsightStore.upsertCandidates({
+      projectId,
+      candidates: [makeCandidate()],
+      now,
+    });
+
+    expect(create).not.toHaveBeenCalled();
+    expect(result.suppressed).toBe(1);
+  });
 });
 
 describe("InsightStore.upsertCandidates — per-scan new-insight cap", () => {

package/Tests/Server/Utils/AI/Insights/InvestigationQueueInsightSubject.test.ts

@@ -8,6 +8,7 @@ import AIService from "../../../../../Server/Services/AIService";
 import ProjectService from "../../../../../Server/Services/ProjectService";
 import Project from "../../../../../Models/DatabaseModels/Project";
 import AIRun from "../../../../../Models/DatabaseModels/AIRun";
+import AIRunCodeFixRecommendation from "../../../../../Types/AI/AIRunCodeFixRecommendation";
 import AIRunStatus from "../../../../../Types/AI/AIRunStatus";
 import AIRunType from "../../../../../Types/AI/AIRunType";
 import ObjectID from "../../../../../Types/ObjectID";
@@ -76,6 +77,7 @@ describe("AIInvestigationQueue — insight subject", () => {
         data: expect.objectContaining({
           status: AIRunStatus.Queued,
           triggeredByAiInsightId: insightId,
+          codeFixRecommendation: AIRunCodeFixRecommendation.NotRecommended,
         }),
         props: expect.objectContaining({ isRoot: true }),
       }),