@oneuptime/common 11.4.0 → 11.5.0

package/Server/Utils/Monitor/SnmpInterfaceRateUtil.ts

@@ -0,0 +1,169 @@
+import { JSONObject } from "../../../Types/JSON";
+import SnmpInterface from "../../../Types/Monitor/SnmpMonitor/SnmpInterface";
+import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
+import OneUptimeDate from "../../../Types/Date";
+import logger from "../Logger";
+
+/*
+ * Computes per-interface rates (bandwidth, utilization, errors) for SNMP
+ * monitors by comparing the cumulative IF-MIB counters of the current check
+ * against the previous check stored in MonitorProbe.lastMonitoringLog.
+ *
+ * Probes stay stateless — the delta is computed here, on ingest, before the
+ * response is persisted. Negative deltas (counter wrap or device reboot) are
+ * skipped for that interface; rates resume on the following check.
+ */
+export default class SnmpInterfaceRateUtil {
+  public static attachInterfaceRates(data: {
+    probeMonitorResponse: ProbeMonitorResponse;
+    previousStepLog: JSONObject | undefined;
+  }): void {
+    const interfaces: Array<SnmpInterface> | undefined =
+      data.probeMonitorResponse.snmpResponse?.interfaces;
+
+    if (!interfaces || interfaces.length === 0) {
+      return;
+    }
+
+    if (!data.previousStepLog) {
+      return;
+    }
+
+    const previousSnmpResponse: JSONObject | undefined = data.previousStepLog[
+      "snmpResponse"
+    ] as JSONObject | undefined;
+
+    const previousInterfaces: Array<JSONObject> | undefined =
+      previousSnmpResponse?.["interfaces"] as Array<JSONObject> | undefined;
+
+    const previousMonitoredAtValue: unknown =
+      data.previousStepLog["monitoredAt"];
+
+    if (
+      !previousInterfaces ||
+      previousInterfaces.length === 0 ||
+      !previousMonitoredAtValue
+    ) {
+      return;
+    }
+
+    const previousMonitoredAt: Date = new Date(
+      previousMonitoredAtValue as string,
+    );
+
+    if (isNaN(previousMonitoredAt.getTime())) {
+      return;
+    }
+
+    /*
+     * lastMonitoringLog stores server receipt time as monitoredAt, so the
+     * current side of the delta uses server time too.
+     */
+    const elapsedSeconds: number =
+      (OneUptimeDate.getCurrentDate().getTime() -
+        previousMonitoredAt.getTime()) /
+      1000;
+
+    if (elapsedSeconds <= 0) {
+      return;
+    }
+
+    const counterDelta: (
+      currentValue: number | undefined,
+      previousValue: unknown,
+    ) => number | undefined = (
+      currentValue: number | undefined,
+      previousValue: unknown,
+    ) => {
+      if (
+        currentValue === undefined ||
+        typeof previousValue !== "number" ||
+        !isFinite(previousValue)
+      ) {
+        return undefined;
+      }
+
+      const delta: number = currentValue - previousValue;
+
+      // Negative delta: counter wrapped or the device rebooted.
+      return delta >= 0 ? delta : undefined;
+    };
+
+    const round: (value: number) => number = (value: number) => {
+      return Math.round(value * 100) / 100;
+    };
+
+    const previousByIndex: Map<number, JSONObject> = new Map();
+    for (const previousInterface of previousInterfaces) {
+      const index: unknown = previousInterface["interfaceIndex"];
+      if (typeof index === "number") {
+        previousByIndex.set(index, previousInterface);
+      }
+    }
+
+    for (const currentInterface of interfaces) {
+      const previousInterface: JSONObject | undefined = previousByIndex.get(
+        currentInterface.interfaceIndex,
+      );
+
+      if (!previousInterface) {
+        continue;
+      }
+
+      const inOctetsDelta: number | undefined = counterDelta(
+        currentInterface.inOctets,
+        previousInterface["inOctets"],
+      );
+      const outOctetsDelta: number | undefined = counterDelta(
+        currentInterface.outOctets,
+        previousInterface["outOctets"],
+      );
+
+      if (inOctetsDelta !== undefined) {
+        currentInterface.inBitsPerSecond = round(
+          (inOctetsDelta * 8) / elapsedSeconds,
+        );
+      }
+
+      if (outOctetsDelta !== undefined) {
+        currentInterface.outBitsPerSecond = round(
+          (outOctetsDelta * 8) / elapsedSeconds,
+        );
+      }
+
+      if (
+        currentInterface.speedInBitsPerSecond &&
+        currentInterface.speedInBitsPerSecond > 0 &&
+        (currentInterface.inBitsPerSecond !== undefined ||
+          currentInterface.outBitsPerSecond !== undefined)
+      ) {
+        const busiestDirectionBps: number = Math.max(
+          currentInterface.inBitsPerSecond || 0,
+          currentInterface.outBitsPerSecond || 0,
+        );
+        currentInterface.utilizationPercent = round(
+          (busiestDirectionBps / currentInterface.speedInBitsPerSecond) * 100,
+        );
+      }
+
+      const inErrorsDelta: number | undefined = counterDelta(
+        currentInterface.inErrors,
+        previousInterface["inErrors"],
+      );
+      const outErrorsDelta: number | undefined = counterDelta(
+        currentInterface.outErrors,
+        previousInterface["outErrors"],
+      );
+
+      if (inErrorsDelta !== undefined || outErrorsDelta !== undefined) {
+        currentInterface.errorsPerSecond = round(
+          ((inErrorsDelta || 0) + (outErrorsDelta || 0)) / elapsedSeconds,
+        );
+      }
+    }
+
+    logger.debug(
+      `Attached SNMP interface rates for monitor ${data.probeMonitorResponse.monitorId.toString()} over ${round(elapsedSeconds)}s window`,
+    );
+  }
+}

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

@@ -0,0 +1,146 @@
+import AIAgentTaskService from "../../../Server/Services/AIAgentTaskService";
+import Model from "../../../Models/DatabaseModels/AIAgentTask";
+import AIAgentTaskStatus from "../../../Types/AI/AIAgentTaskStatus";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * claimNextScheduledTask is the atomic-claim fix for the get-pending-task
+ * double-processing race: multiple KEDA-scaled AIAgent workers poll the same
+ * endpoint, and the old plain findOneBy returned the oldest Scheduled task
+ * without mutating it, so two workers could both receive — and both execute —
+ * the same task.
+ *
+ * The claim collapses the read-then-take into findOneBy + a status-guarded
+ * updateOneBy (Scheduled -> InProgress). updateOneBy returns the number of
+ * rows changed: 1 means this caller won the claim; 0 means another worker
+ * already took the task, and the loop retries with the next candidate.
+ *
+ * These tests mock the two inherited persistence helpers (no Postgres) to
+ * lock in:
+ *   (a) a won claim returns the task, with the guard and the InProgress
+ *       transition on the exact row that was read;
+ *   (b) a lost claim (0 rows) is never returned — the loop moves to the
+ *       next candidate;
+ *   (c) no Scheduled tasks => null, with no write at all;
+ *   (d) the retry loop is bounded, so a pathological all-losses storm
+ *       terminates.
+ */
+
+function fakeTask(id: ObjectID): Model {
+  return {
+    id,
+    _id: id.toString(),
+    projectId: ObjectID.generate(),
+    taskType: "FixException",
+  } as unknown as Model;
+}
+
+describe("AIAgentTaskService.claimNextScheduledTask", () => {
+  const aiAgentId: ObjectID = ObjectID.generate();
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns the task when the claim wins, guarding on Scheduled status", async () => {
+    const task: Model = fakeTask(ObjectID.generate());
+
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIAgentTaskService, "findOneBy")
+      .mockResolvedValue(task);
+    const updateOneBy: jest.SpyInstance = jest
+      .spyOn(AIAgentTaskService, "updateOneBy")
+      .mockResolvedValue(1);
+
+    const claimed: Model | null =
+      await AIAgentTaskService.claimNextScheduledTask({
+        aiAgentId: aiAgentId,
+      });
+
+    expect(claimed).toBe(task);
+    expect(findOneBy).toHaveBeenCalledTimes(1);
+    expect(findOneBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: { status: AIAgentTaskStatus.Scheduled },
+      }),
+    );
+    expect(updateOneBy).toHaveBeenCalledTimes(1);
+    expect(updateOneBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: {
+          _id: task.id!.toString(),
+          status: AIAgentTaskStatus.Scheduled,
+        },
+        data: expect.objectContaining({
+          status: AIAgentTaskStatus.InProgress,
+          aiAgentId: aiAgentId,
+          startedAt: expect.any(Date),
+        }),
+      }),
+    );
+  });
+
+  test("retries with the next candidate when another worker wins the race", async () => {
+    const lostTask: Model = fakeTask(ObjectID.generate());
+    const wonTask: Model = fakeTask(ObjectID.generate());
+
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIAgentTaskService, "findOneBy")
+      .mockResolvedValueOnce(lostTask)
+      .mockResolvedValueOnce(wonTask);
+    const updateOneBy: jest.SpyInstance = jest
+      .spyOn(AIAgentTaskService, "updateOneBy")
+      .mockResolvedValueOnce(0)
+      .mockResolvedValueOnce(1);
+
+    const claimed: Model | null =
+      await AIAgentTaskService.claimNextScheduledTask({
+        aiAgentId: aiAgentId,
+      });
+
+    expect(claimed).toBe(wonTask);
+    expect(findOneBy).toHaveBeenCalledTimes(2);
+    expect(updateOneBy).toHaveBeenCalledTimes(2);
+    expect(updateOneBy).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        query: {
+          _id: wonTask.id!.toString(),
+          status: AIAgentTaskStatus.Scheduled,
+        },
+      }),
+    );
+  });
+
+  test("returns null without writing when no Scheduled task exists", async () => {
+    jest.spyOn(AIAgentTaskService, "findOneBy").mockResolvedValue(null);
+    const updateOneBy: jest.SpyInstance = jest
+      .spyOn(AIAgentTaskService, "updateOneBy")
+      .mockResolvedValue(1);
+
+    const claimed: Model | null =
+      await AIAgentTaskService.claimNextScheduledTask({
+        aiAgentId: aiAgentId,
+      });
+
+    expect(claimed).toBeNull();
+    expect(updateOneBy).not.toHaveBeenCalled();
+  });
+
+  test("gives up after a bounded number of lost claims", async () => {
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIAgentTaskService, "findOneBy")
+      .mockImplementation(async () => {
+        return fakeTask(ObjectID.generate());
+      });
+    jest.spyOn(AIAgentTaskService, "updateOneBy").mockResolvedValue(0);
+
+    const claimed: Model | null =
+      await AIAgentTaskService.claimNextScheduledTask({
+        aiAgentId: aiAgentId,
+      });
+
+    expect(claimed).toBeNull();
+    expect(findOneBy).toHaveBeenCalledTimes(5);
+  });
+});

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

@@ -0,0 +1,173 @@
+import AIService, {
+  AUTONOMOUS_AI_FEATURES,
+  AutonomousBudgetStatus,
+} from "../../../Server/Services/AIService";
+import SentinelInvestigationQueue from "../../../Server/Utils/AI/Sentinel/InvestigationQueue";
+import LlmLogService from "../../../Server/Services/LlmLogService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import AIRunService from "../../../Server/Services/AIRunService";
+import Project from "../../../Models/DatabaseModels/Project";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * G4 daily budget: Project.aiDailyAutonomousTokenLimit bounds the tokens the
+ * AUTONOMOUS_AI_FEATURES may consume per UTC day. The engine skips new
+ * investigations quietly when the budget is exhausted (no Error run created);
+ * AIService.executeWithLogging is the hard backstop mid-run. Interactive chat
+ * is never blocked — its features are not in AUTONOMOUS_AI_FEATURES.
+ *
+ * These tests mock the persistence layer and lock in:
+ *   (a) no limit configured => never exhausted, and no usage query is run;
+ *   (b) usage below the limit => not exhausted;
+ *   (c) usage at/over the limit => exhausted, with the numbers reported;
+ *   (d) the engine skips run creation when the budget is exhausted.
+ */
+
+function fakeProject(limit: number | undefined): Project {
+  return {
+    id: ObjectID.generate(),
+    aiDailyAutonomousTokenLimit: limit,
+  } as unknown as Project;
+}
+
+describe("AIService.getAutonomousDailyBudgetStatus", () => {
+  const projectId: ObjectID = ObjectID.generate();
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("no configured limit means never exhausted and no usage query", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(undefined));
+    const getTokens: jest.SpyInstance = jest.spyOn(
+      LlmLogService,
+      "getTotalTokensUsedSince",
+    );
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(false);
+    expect(status.limitInTokens).toBeNull();
+    expect(getTokens).not.toHaveBeenCalled();
+  });
+
+  test("a limit of 0 pauses autonomous runs without querying usage", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject(0));
+    const getTokens: jest.SpyInstance = jest.spyOn(
+      LlmLogService,
+      "getTotalTokensUsedSince",
+    );
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(true);
+    expect(status.limitInTokens).toBe(0);
+    expect(getTokens).not.toHaveBeenCalled();
+  });
+
+  test("usage below the limit is not exhausted", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(100_000));
+    jest
+      .spyOn(LlmLogService, "getTotalTokensUsedSince")
+      .mockResolvedValue(99_999);
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(false);
+    expect(status.limitInTokens).toBe(100_000);
+    expect(status.usedTokensToday).toBe(99_999);
+  });
+
+  test("usage at the limit is exhausted, scoped to autonomous features", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(100_000));
+    const getTokens: jest.SpyInstance = jest
+      .spyOn(LlmLogService, "getTotalTokensUsedSince")
+      .mockResolvedValue(100_000);
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(true);
+    expect(getTokens).toHaveBeenCalledWith(
+      expect.objectContaining({
+        features: AUTONOMOUS_AI_FEATURES,
+      }),
+    );
+  });
+});
+
+describe("SentinelInvestigationQueue budget skip", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("does not enqueue when the daily budget is exhausted", async () => {
+    jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+      exhausted: true,
+      limitInTokens: 100_000,
+      usedTokensToday: 120_000,
+    });
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await SentinelInvestigationQueue.enqueue({
+      projectId: ObjectID.generate(),
+      subjectAlertId: ObjectID.generate(),
+    });
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("does not enqueue when the budget check itself fails", async () => {
+    jest
+      .spyOn(AIService, "getAutonomousDailyBudgetStatus")
+      .mockRejectedValue(new Error("db down"));
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await SentinelInvestigationQueue.enqueue({
+      projectId: ObjectID.generate(),
+      subjectAlertId: ObjectID.generate(),
+    });
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("leaves a queued run unclaimed when the budget is exhausted at claim time", async () => {
+    // No per-project cap override; concurrency cap passes…
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(undefined));
+    jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(0));
+    // …but the budget is exhausted.
+    jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+      exhausted: true,
+      limitInTokens: 100_000,
+      usedTokensToday: 120_000,
+    });
+    const claim: jest.SpyInstance = jest.spyOn(
+      AIRunService,
+      "attemptStatusTransition",
+    );
+
+    await SentinelInvestigationQueue.processRun({
+      id: ObjectID.generate(),
+      projectId: ObjectID.generate(),
+      attemptCount: 0,
+      triggeredByAlertId: ObjectID.generate(),
+    });
+
+    expect(claim).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,97 @@
+import IncidentInternalNoteService from "../../../Server/Services/IncidentInternalNoteService";
+import IncidentFeedService from "../../../Server/Services/IncidentFeedService";
+import IncidentService from "../../../Server/Services/IncidentService";
+import Model from "../../../Models/DatabaseModels/IncidentInternalNote";
+import ObjectID from "../../../Types/ObjectID";
+import URL from "../../../Types/API/URL";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * IncidentInternalNoteService.onCreateSuccess announces every new note with a
+ * "posted private note" feed item + workspace ping — INCLUDING user-less
+ * system notes: the SLA note-reminder job (SendNoteReminders.ts) creates notes
+ * with no createdByUserId and relies entirely on this hook for its feed entry
+ * and Slack/Teams ping (it sets isOwnerNotified itself, so the hook is its
+ * only push channel).
+ *
+ * Callers that must NOT announce (Sentinel's RCA note, which has its own
+ * quiet-mode-gated RootCause feed item) opt out explicitly with
+ * props.ignoreHooks — see IncidentInvestigationRunner. These tests lock in
+ * that the hook announces for both user-authored and user-less notes, so the
+ * SLA flow can't be silenced again by a "system notes are quiet" shortcut.
+ */
+
+function fakeNote(userId?: ObjectID | undefined): Model {
+  return {
+    id: ObjectID.generate(),
+    incidentId: ObjectID.generate(),
+    projectId: ObjectID.generate(),
+    note: "test note",
+    createdByUserId: userId,
+    createdByUser: undefined,
+  } as unknown as Model;
+}
+
+describe("IncidentInternalNoteService.onCreateSuccess", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function mockAnnouncementDeps(): jest.SpyInstance {
+    const createFeedItem: jest.SpyInstance = jest
+      .spyOn(IncidentFeedService, "createIncidentFeedItem")
+      .mockResolvedValue(undefined as never);
+    jest.spyOn(IncidentService, "getIncidentNumber").mockResolvedValue({
+      number: 42,
+      numberWithPrefix: "INC-42",
+    });
+    jest
+      .spyOn(IncidentService, "getIncidentLinkInDashboard")
+      .mockResolvedValue(URL.fromString("https://oneuptime.example/incident"));
+    // No attachments on these notes.
+    jest
+      .spyOn(IncidentInternalNoteService, "findOneById")
+      .mockResolvedValue(null);
+    return createFeedItem;
+  }
+
+  test("user-authored note announces with a feed item attributed to the user", async () => {
+    const createFeedItem: jest.SpyInstance = mockAnnouncementDeps();
+    const userId: ObjectID = ObjectID.generate();
+    const note: Model = fakeNote(userId);
+
+    await IncidentInternalNoteService.onCreateSuccess(
+      { createBy: { data: note, props: { isRoot: true } }, carryForward: null },
+      note,
+    );
+
+    expect(createFeedItem).toHaveBeenCalledTimes(1);
+    expect(createFeedItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        userId,
+        workspaceNotification: expect.objectContaining({
+          sendWorkspaceNotification: true,
+        }),
+      }),
+    );
+  });
+
+  test("user-less system note (e.g. SLA reminder) still announces", async () => {
+    const createFeedItem: jest.SpyInstance = mockAnnouncementDeps();
+    const note: Model = fakeNote(undefined);
+
+    await IncidentInternalNoteService.onCreateSuccess(
+      { createBy: { data: note, props: { isRoot: true } }, carryForward: null },
+      note,
+    );
+
+    expect(createFeedItem).toHaveBeenCalledTimes(1);
+    expect(createFeedItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceNotification: expect.objectContaining({
+          sendWorkspaceNotification: true,
+        }),
+      }),
+    );
+  });
+});

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

@@ -278,3 +278,57 @@ describe("IoTDeviceService.bulkUpdateLatestMetrics — sanitation matches the up
     expect(params).not.toContain(10);
   });
 });
+
+describe("IoTDeviceService.deleteStaleForFleet — registered devices survive", () => {
+  const CUTOFF: Date = new Date("2026-06-13T00:00:00.000Z");
+
+  test("marks registered devices offline and deletes only unregistered ones", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    query
+      .mockResolvedValueOnce([[], 2]) // UPDATE (registered -> isUp=false)
+      .mockResolvedValueOnce([[], 5]); // DELETE (unregistered)
+
+    const result: { deleted: number; markedOffline: number } =
+      await IoTDeviceService.deleteStaleForFleet({
+        iotFleetId: FLEET_ID,
+        olderThan: CUTOFF,
+      });
+
+    expect(query).toHaveBeenCalledTimes(2);
+
+    const [updateSql, updateParams] = query.mock.calls[0] as QueryCall;
+    expect(updateSql).toContain('UPDATE "IoTDevice" SET "isUp" = false');
+    // Registered = credential on the same project + fleet + externalId.
+    expect(updateSql).toContain('EXISTS (SELECT 1 FROM "IoTDeviceCredential"');
+    expect(updateSql).toContain('c."externalId" = "IoTDevice"."externalId"');
+    expect(updateSql).toContain('c."projectId" = "IoTDevice"."projectId"');
+    // The credential correlation itself is kind-agnostic.
+    expect(updateSql).not.toContain('c."kind"');
+    // Reconnect recovery depends on lastSeenAt staying untouched.
+    expect(updateSql).not.toContain('"lastSeenAt" =');
+    // Idempotent across cron ticks: already-down rows are not rewritten.
+    expect(updateSql).toContain('"isUp" IS DISTINCT FROM false');
+    // Stale duplicate-kind rows self-heal instead of being pinned offline.
+    expect(updateSql).toContain("NOT EXISTS");
+    expect(updateParams).toEqual([FLEET_ID.toString(), CUTOFF]);
+
+    const [deleteSql, deleteParams] = query.mock.calls[1] as QueryCall;
+    expect(deleteSql).toContain('DELETE FROM "IoTDevice"');
+    expect(deleteSql).toContain("NOT EXISTS");
+    expect(deleteParams).toEqual([FLEET_ID.toString(), CUTOFF]);
+
+    expect(result).toEqual({ deleted: 5, markedOffline: 2 });
+  });
+
+  test("normalizes a driver result without an affected count to zero", async () => {
+    mockQueryRunner([]);
+
+    const result: { deleted: number; markedOffline: number } =
+      await IoTDeviceService.deleteStaleForFleet({
+        iotFleetId: FLEET_ID,
+        olderThan: CUTOFF,
+      });
+
+    expect(result).toEqual({ deleted: 0, markedOffline: 0 });
+  });
+});

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

@@ -98,6 +98,7 @@ describe("LogAggregationService", () => {
     ).buildHistogramStatement({
       ...defaultRequest,
       facetKey: undefined,
+      bucketSizeInMinutes: 60,
       attributes: { requestid: "uuid-123" },
     });
 
@@ -110,4 +111,25 @@ describe("LogAggregationService", () => {
     expect(Object.values(statement.query_params)).toContain("requestid");
     expect(Object.values(statement.query_params)).toContain("uuid-123");
   });
+
+  test("histogram supports multi-value dashboard attribute filters", () => {
+    const statement: Statement = (
+      LogAggregationService as any
+    ).buildHistogramStatement({
+      ...defaultRequest,
+      facetKey: undefined,
+      bucketSizeInMinutes: 60,
+      attributes: { region: ["eu-west-1", "us-east-1"] },
+    });
+
+    expect(statement.query).toContain(
+      "arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(",
+    );
+    expect(statement.query).toContain("AND v IN (");
+    expect(Object.values(statement.query_params)).toContain("region");
+    expect(Object.values(statement.query_params)).toContainEqual([
+      "eu-west-1",
+      "us-east-1",
+    ]);
+  });
 });