@oneuptime/common 14.0.10 → 14.0.11

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

@@ -39,7 +39,19 @@ import RumApplicationService from "../../../Server/Services/RumApplicationServic
 import TelemetryRetentionConfig from "../../../Types/Telemetry/TelemetryRetentionConfig";
 import ServiceType from "../../../Types/Telemetry/ServiceType";
 import ObjectID from "../../../Types/ObjectID";
-import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+import {
+  installFakeEnterpriseModule,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
 
 /*
  * The L1 memo inside OTelIngestService.getResourceRetention.
@@ -144,6 +156,21 @@ const RETENTION_CASES: Array<RetentionCase> = [
 ];
 
 const PROJECT_DEFAULT_RETENTION_DAYS: number = 15;
+
+/*
+ * Retention overrides are an Enterprise feature: ingest applies them only
+ * while EnterpriseFeature.TelemetryRetention is active. These suites are
+ * about the caches, so they run as a licensed Enterprise Edition (a valid
+ * license is active with billing on or off). The Community Edition path is
+ * pinned in OpenTelemetryRetentionOverrideEdition.test.ts.
+ */
+beforeAll(() => {
+  installFakeEnterpriseModule();
+});
+
+afterAll(() => {
+  uninstallEnterpriseModule();
+});
 const RESOURCE_RETENTION_CONFIG: TelemetryRetentionConfig = {
   logs: { default: 45 },
   traces: { default: 60 },

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

@@ -0,0 +1,474 @@
+import GlobalCache from "../../../Server/Infrastructure/GlobalCache";
+import OTelIngestService, {
+  TelemetryServiceMetadata,
+} from "../../../Server/Services/OpenTelemetryIngestService";
+import HostService from "../../../Server/Services/HostService";
+import KubernetesClusterService from "../../../Server/Services/KubernetesClusterService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import ServiceService from "../../../Server/Services/ServiceService";
+import EnterpriseFeature from "../../../Server/Enterprise/EnterpriseFeature";
+import Service from "../../../Models/DatabaseModels/Service";
+import { SpanStatus } from "../../../Models/AnalyticsModels/Span";
+import LogSeverity from "../../../Types/Log/LogSeverity";
+import ObjectID from "../../../Types/ObjectID";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import TelemetryRetentionConfig, {
+  resolveTelemetryRetentionInDays,
+} from "../../../Types/Telemetry/TelemetryRetentionConfig";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import FakeEnterpriseModule, {
+  createEditionStateCases,
+  createLicenseSnapshot,
+  createLicenseSnapshotWithStatus,
+  EditionStateCase,
+  installFakeEnterpriseModule,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
+import { setTestBillingEnabled } from "../Enterprise/TestBillingFlag";
+
+/*
+ * Retention overrides are an Enterprise feature
+ * (EnterpriseFeature.TelemetryRetention). Ingest applies them only while the
+ * feature is active; otherwise every row gets the project's default
+ * retention, and the configured overrides are kept, unused.
+ *
+ * Every signal (logs, traces, metrics, profiles, security events, change
+ * events, syslog, fluent) resolves a row's retention from the
+ * TelemetryServiceMetadata built here, with resolveTelemetryRetentionInDays,
+ * so this is the one place the edition is decided. Pinned here:
+ *
+ *   - applyRetentionOverrideEdition, in every billing / edition / license
+ *     state: overrides kept exactly while the feature is active;
+ *   - a license that leaves retention overrides out drops them, one that
+ *     names only them keeps them;
+ *   - the real metadata builders, for a Service (per-service retention and
+ *     retention by type, plus the project's retention by type) and for a
+ *     resource (Host, Kubernetes cluster): on the Community Edition the row
+ *     gets the project's default whatever is configured;
+ *   - a license change takes effect on the next row, with every cache warm.
+ *
+ * Billing and the edition are pinned in every test: CI's config.env sets
+ * BILLING_ENABLED=true.
+ */
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  const billingFlag: typeof import("../Enterprise/TestBillingFlag") =
+    jest.requireActual(
+      "../Enterprise/TestBillingFlag",
+    ) as typeof import("../Enterprise/TestBillingFlag");
+
+  return billingFlag.withLiveBillingFlag(
+    jest.requireActual("../../../Server/EnvironmentConfig") as Record<
+      string,
+      unknown
+    >,
+  );
+});
+
+/*
+ * PasswordHash carries a pre-existing TS5.9 diagnostic that fails any suite
+ * whose runtime require graph reaches it (DatabaseService, the base class of
+ * every concrete service, imports it). Nothing password-related is under
+ * test here, so the module is replaced WITH A FACTORY.
+ */
+jest.mock("../../../Server/Utils/PasswordHash", () => {
+  return {
+    __esModule: true,
+    default: {
+      hash: jest.fn(),
+      verify: jest.fn(),
+      generateSalt: jest.fn(),
+      needsUpgrade: jest.fn(),
+      applyPepper: jest.fn(),
+    },
+  };
+});
+
+jest.mock("../../../Server/Utils/Telemetry/EntityRegistry", () => {
+  return {
+    __esModule: true,
+    reconcileEntityRegistryThrottled: jest.fn(),
+  };
+});
+
+const PROJECT_DEFAULT_DAYS: number = 15;
+
+const PROJECT_CONFIG: TelemetryRetentionConfig = {
+  logs: { default: 20 },
+  traces: { default: 21, byStatus: { [SpanStatus.Error]: 120 } },
+};
+
+const OVERRIDE_CONFIG: TelemetryRetentionConfig = {
+  logs: { default: 45, bySeverity: { [LogSeverity.Error]: 90 } },
+  metrics: { default: 60 },
+};
+
+const OVERRIDE_DAYS: number = 30;
+
+const metadataWithOverrides: () => TelemetryServiceMetadata =
+  (): TelemetryServiceMetadata => {
+    return {
+      serviceName: "checkout",
+      primaryEntityId: ObjectID.generate(),
+      primaryEntityType: ServiceType.OpenTelemetry,
+      dataRententionInDays: OVERRIDE_DAYS,
+      serviceRetentionConfig: OVERRIDE_CONFIG,
+      serviceRetentionInDays: OVERRIDE_DAYS,
+      projectRetentionConfig: PROJECT_CONFIG,
+      projectRetentionInDays: PROJECT_DEFAULT_DAYS,
+    };
+  };
+
+// What a row of each kind would be stamped with.
+const retentionOf: (
+  metadata: TelemetryServiceMetadata,
+) => Record<string, number> = (
+  metadata: TelemetryServiceMetadata,
+): Record<string, number> => {
+  const common: {
+    serviceConfig: TelemetryRetentionConfig | null;
+    serviceRetentionInDays: number | null;
+    projectConfig: TelemetryRetentionConfig | null;
+    projectRetentionInDays: number;
+  } = {
+    serviceConfig: metadata.serviceRetentionConfig,
+    serviceRetentionInDays: metadata.serviceRetentionInDays,
+    projectConfig: metadata.projectRetentionConfig,
+    projectRetentionInDays: metadata.projectRetentionInDays,
+  };
+
+  return {
+    errorLog: resolveTelemetryRetentionInDays({
+      pillar: "logs",
+      bucketKey: LogSeverity.Error,
+      ...common,
+    }),
+    infoLog: resolveTelemetryRetentionInDays({
+      pillar: "logs",
+      bucketKey: LogSeverity.Information,
+      ...common,
+    }),
+    failedSpan: resolveTelemetryRetentionInDays({
+      pillar: "traces",
+      bucketKey: SpanStatus.Error,
+      ...common,
+    }),
+    metric: resolveTelemetryRetentionInDays({ pillar: "metrics", ...common }),
+    profile: resolveTelemetryRetentionInDays({
+      pillar: "profiles",
+      ...common,
+    }),
+    securityEvent: resolveTelemetryRetentionInDays({
+      pillar: "securityEvents",
+      ...common,
+    }),
+    dataRententionInDays: metadata.dataRententionInDays,
+  };
+};
+
+const EVERYTHING_AT_PROJECT_DEFAULT: Record<string, number> = {
+  errorLog: PROJECT_DEFAULT_DAYS,
+  infoLog: PROJECT_DEFAULT_DAYS,
+  failedSpan: PROJECT_DEFAULT_DAYS,
+  metric: PROJECT_DEFAULT_DAYS,
+  profile: PROJECT_DEFAULT_DAYS,
+  securityEvent: PROJECT_DEFAULT_DAYS,
+  dataRententionInDays: PROJECT_DEFAULT_DAYS,
+};
+
+beforeEach(() => {
+  setTestBillingEnabled(false);
+  uninstallEnterpriseModule();
+
+  // Every cache misses unless a test says otherwise; nothing reaches Redis.
+  jest.spyOn(GlobalCache, "getJSONObject").mockResolvedValue(null);
+  jest.spyOn(GlobalCache, "setJSON").mockResolvedValue(undefined);
+  jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
+    defaultTelemetryRetentionInDays: PROJECT_DEFAULT_DAYS,
+    telemetryRetentionConfig: PROJECT_CONFIG,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any);
+});
+
+afterEach(() => {
+  uninstallEnterpriseModule();
+  setTestBillingEnabled(false);
+  jest.restoreAllMocks();
+});
+
+describe("applyRetentionOverrideEdition", () => {
+  test.each(
+    createEditionStateCases().map((state: EditionStateCase) => {
+      return [state.label, state] as [string, EditionStateCase];
+    }),
+  )("%s", (_label: string, state: EditionStateCase) => {
+    state.apply();
+
+    const metadata: TelemetryServiceMetadata = metadataWithOverrides();
+    const applied: TelemetryServiceMetadata =
+      OTelIngestService.applyRetentionOverrideEdition(metadata);
+
+    if (state.isActive) {
+      // The same object: nothing is copied on the hot path.
+      expect(applied).toBe(metadata);
+      return;
+    }
+
+    expect(applied).toEqual({
+      ...metadata,
+      dataRententionInDays: PROJECT_DEFAULT_DAYS,
+      serviceRetentionConfig: null,
+      serviceRetentionInDays: null,
+      projectRetentionConfig: null,
+    });
+    // The input is not mutated: a cached metadata object stays intact.
+    expect(metadata.serviceRetentionConfig).toBe(OVERRIDE_CONFIG);
+    expect(retentionOf(applied)).toEqual(EVERYTHING_AT_PROJECT_DEFAULT);
+  });
+
+  test("keeps the service identity and entity keys when it drops the overrides", () => {
+    const metadata: TelemetryServiceMetadata = {
+      ...metadataWithOverrides(),
+      entityKeys: ["service:abc"],
+    };
+    const applied: TelemetryServiceMetadata =
+      OTelIngestService.applyRetentionOverrideEdition(metadata);
+
+    expect(applied.serviceName).toBe(metadata.serviceName);
+    expect(applied.primaryEntityId).toBe(metadata.primaryEntityId);
+    expect(applied.primaryEntityType).toBe(metadata.primaryEntityType);
+    expect(applied.entityKeys).toEqual(["service:abc"]);
+  });
+
+  test("a license that leaves retention overrides out drops them", () => {
+    installFakeEnterpriseModule({
+      snapshot: createLicenseSnapshot({
+        features: [
+          EnterpriseFeature.SCIM,
+          EnterpriseFeature.AuditLogs,
+          EnterpriseFeature.TeamCompliance,
+          EnterpriseFeature.InstanceHealth,
+        ],
+      }),
+    });
+
+    expect(
+      retentionOf(
+        OTelIngestService.applyRetentionOverrideEdition(
+          metadataWithOverrides(),
+        ),
+      ),
+    ).toEqual(EVERYTHING_AT_PROJECT_DEFAULT);
+  });
+
+  test("a license that names only retention overrides keeps them", () => {
+    installFakeEnterpriseModule({
+      snapshot: createLicenseSnapshot({
+        features: [EnterpriseFeature.TelemetryRetention],
+      }),
+    });
+
+    expect(
+      retentionOf(
+        OTelIngestService.applyRetentionOverrideEdition(
+          metadataWithOverrides(),
+        ),
+      ),
+    ).toEqual({
+      errorLog: 90,
+      infoLog: 45,
+      failedSpan: OVERRIDE_DAYS,
+      metric: 60,
+      profile: OVERRIDE_DAYS,
+      securityEvent: OVERRIDE_DAYS,
+      dataRententionInDays: OVERRIDE_DAYS,
+    });
+  });
+});
+
+describe("a Service's telemetry", () => {
+  const serviceWithOverrides: () => Service = (): Service => {
+    const service: Service = new Service();
+    service._id = ObjectID.generate().toString();
+    service.retainTelemetryDataForDays = OVERRIDE_DAYS;
+    service.telemetryRetentionConfig = OVERRIDE_CONFIG;
+    return service;
+  };
+
+  beforeEach(() => {
+    jest
+      .spyOn(ServiceService, "updateLastSeen")
+      .mockResolvedValue(undefined as never);
+  });
+
+  const build: () => Promise<TelemetryServiceMetadata> =
+    async (): Promise<TelemetryServiceMetadata> => {
+      // Fresh names and projects keep the module-level caches cold.
+      return OTelIngestService.telemetryServiceFromName({
+        serviceName: `svc-${ObjectID.generate().toString()}`,
+        projectId: ObjectID.generate(),
+      });
+    };
+
+  test("Community Edition: the project's default retention for every row, whatever is configured", async () => {
+    jest
+      .spyOn(ServiceService, "findOneBy")
+      .mockResolvedValue(serviceWithOverrides());
+
+    expect(retentionOf(await build())).toEqual(EVERYTHING_AT_PROJECT_DEFAULT);
+  });
+
+  test("licensed Enterprise Edition: the service's overrides, then the project's retention by type", async () => {
+    installFakeEnterpriseModule();
+    jest
+      .spyOn(ServiceService, "findOneBy")
+      .mockResolvedValue(serviceWithOverrides());
+
+    expect(retentionOf(await build())).toEqual({
+      errorLog: 90,
+      infoLog: 45,
+      failedSpan: OVERRIDE_DAYS,
+      metric: 60,
+      profile: OVERRIDE_DAYS,
+      securityEvent: OVERRIDE_DAYS,
+      dataRententionInDays: OVERRIDE_DAYS,
+    });
+  });
+
+  test("licensed Enterprise Edition, a service with no overrides: the project's retention by type applies", async () => {
+    installFakeEnterpriseModule();
+    const plain: Service = new Service();
+    plain._id = ObjectID.generate().toString();
+    jest.spyOn(ServiceService, "findOneBy").mockResolvedValue(plain);
+
+    expect(retentionOf(await build())).toEqual({
+      errorLog: 20,
+      infoLog: 20,
+      failedSpan: 120,
+      metric: PROJECT_DEFAULT_DAYS,
+      profile: PROJECT_DEFAULT_DAYS,
+      securityEvent: PROJECT_DEFAULT_DAYS,
+      dataRententionInDays: PROJECT_DEFAULT_DAYS,
+    });
+  });
+
+  test("Community Edition: the project's retention by type is dropped too", async () => {
+    const plain: Service = new Service();
+    plain._id = ObjectID.generate().toString();
+    jest.spyOn(ServiceService, "findOneBy").mockResolvedValue(plain);
+
+    expect(retentionOf(await build())).toEqual(EVERYTHING_AT_PROJECT_DEFAULT);
+  });
+
+  test("a lapsed license drops them, like the Community Edition", async () => {
+    installFakeEnterpriseModule({
+      snapshot: createLicenseSnapshotWithStatus("expired"),
+    });
+    jest
+      .spyOn(ServiceService, "findOneBy")
+      .mockResolvedValue(serviceWithOverrides());
+
+    expect(retentionOf(await build())).toEqual(EVERYTHING_AT_PROJECT_DEFAULT);
+  });
+
+  test("OneUptime Cloud keeps them: the plan gates writes, not ingest", async () => {
+    setTestBillingEnabled(true);
+    installFakeEnterpriseModule();
+    jest
+      .spyOn(ServiceService, "findOneBy")
+      .mockResolvedValue(serviceWithOverrides());
+
+    expect((await build()).dataRententionInDays).toBe(OVERRIDE_DAYS);
+  });
+});
+
+describe.each([
+  ["Host", ServiceType.Host, HostService],
+  [
+    "Kubernetes cluster",
+    ServiceType.KubernetesCluster,
+    KubernetesClusterService,
+  ],
+])(
+  "a %s's telemetry",
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (_name: string, serviceType: ServiceType, service: any) => {
+    let findOneById: jest.SpiedFunction<() => Promise<unknown>>;
+
+    beforeEach(() => {
+      findOneById = jest.spyOn(service, "findOneById").mockResolvedValue({
+        retainTelemetryDataForDays: OVERRIDE_DAYS,
+        telemetryRetentionConfig: OVERRIDE_CONFIG,
+      } as never) as unknown as jest.SpiedFunction<() => Promise<unknown>>;
+    });
+
+    const build: (
+      resourceId: ObjectID,
+      projectId: ObjectID,
+    ) => Promise<TelemetryServiceMetadata> = (
+      resourceId: ObjectID,
+      projectId: ObjectID,
+    ): Promise<TelemetryServiceMetadata> => {
+      return OTelIngestService.buildResourceMetadataForNonService({
+        serviceName: "resource-under-test",
+        resourceId,
+        primaryEntityType: serviceType,
+        projectId,
+      });
+    };
+
+    test("Community Edition: the project's default retention", async () => {
+      expect(
+        retentionOf(await build(ObjectID.generate(), ObjectID.generate())),
+      ).toEqual(EVERYTHING_AT_PROJECT_DEFAULT);
+    });
+
+    test("licensed Enterprise Edition: the resource's overrides", async () => {
+      installFakeEnterpriseModule();
+
+      const metadata: TelemetryServiceMetadata = await build(
+        ObjectID.generate(),
+        ObjectID.generate(),
+      );
+
+      expect(metadata.dataRententionInDays).toBe(OVERRIDE_DAYS);
+      expect(retentionOf(metadata)["errorLog"]).toBe(90);
+      expect(retentionOf(metadata)["metric"]).toBe(60);
+    });
+
+    test("a license change takes effect on the next row, with every cache warm", async () => {
+      const fake: FakeEnterpriseModule = installFakeEnterpriseModule();
+      const resourceId: ObjectID = ObjectID.generate();
+      const projectId: ObjectID = ObjectID.generate();
+
+      expect((await build(resourceId, projectId)).dataRententionInDays).toBe(
+        OVERRIDE_DAYS,
+      );
+
+      fake.setSnapshot(createLicenseSnapshotWithStatus("expired"));
+
+      expect(retentionOf(await build(resourceId, projectId))).toEqual(
+        EVERYTHING_AT_PROJECT_DEFAULT,
+      );
+
+      fake.setSnapshot(createLicenseSnapshotWithStatus("valid"));
+
+      expect((await build(resourceId, projectId)).dataRententionInDays).toBe(
+        OVERRIDE_DAYS,
+      );
+
+      /*
+       * One Postgres read: the memo served the rest, and the edition was
+       * still asked on every row.
+       */
+      expect(findOneById).toHaveBeenCalledTimes(1);
+    });
+  },
+);

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

@@ -6,13 +6,19 @@ import Service from "../../../Models/DatabaseModels/Service";
 import ObjectID from "../../../Types/ObjectID";
 import { JSONObject } from "../../../Types/JSON";
 import {
+  afterAll,
   afterEach,
+  beforeAll,
   beforeEach,
   describe,
   expect,
   jest,
   test,
 } from "@jest/globals";
+import {
+  installFakeEnterpriseModule,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
 
 /*
  * Regression suite for the Postgres CPU incident.
@@ -123,6 +129,21 @@ const buildService: BuildServiceFunction = (overrides?: {
   return service;
 };
 
+/*
+ * Retention overrides are an Enterprise feature: ingest applies them only
+ * while EnterpriseFeature.TelemetryRetention is active. These suites are
+ * about the caches, so they run as a licensed Enterprise Edition (a valid
+ * license is active with billing on or off). The Community Edition path is
+ * pinned in OpenTelemetryRetentionOverrideEdition.test.ts.
+ */
+beforeAll(() => {
+  installFakeEnterpriseModule();
+});
+
+afterAll(() => {
+  uninstallEnterpriseModule();
+});
+
 describe("OTelIngestService service-resolution cache", () => {
   let findOneBy: jest.Mock;
   let create: jest.Mock;

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

@@ -122,6 +122,9 @@ const OWNER_MODEL_CASES: Array<[string, OwnerModel]> = OWNER_MODELS.map(
 const OWNER_TABLES_CREATED_AFTER_MIGRATION: Array<string> = [
   "DatabaseServerOwnerTeam",
   "DatabaseServerOwnerUser",
+  // 1796700000000-AddMessageQueueTables
+  "MessageQueueOwnerTeam",
+  "MessageQueueOwnerUser",
 ];
 
 const MIGRATED_OWNER_MODELS: Array<OwnerModel> = OWNER_MODELS.filter(

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

@@ -321,7 +321,6 @@ describe("updating a project's audit log settings, billing off", () => {
       installFakeEnterpriseModule({
         snapshot: createLicenseSnapshot({
           features: [
-            EnterpriseFeature.SSO,
             EnterpriseFeature.SCIM,
             EnterpriseFeature.TeamCompliance,
             EnterpriseFeature.InstanceHealth,

package/Tests/Server/Services/RuleRun/LabelRuleEnginesGroupBRun.test.ts

@@ -7,6 +7,9 @@ import IncidentEpisodeLabelRuleEngineService from "../../../../Server/Services/I
 import IncidentEpisodeLabelRuleService from "../../../../Server/Services/IncidentEpisodeLabelRuleService";
 import IncidentEpisodeService from "../../../../Server/Services/IncidentEpisodeService";
 import LabelService from "../../../../Server/Services/LabelService";
+import MessageQueueLabelRuleEngineService from "../../../../Server/Services/MessageQueueLabelRuleEngineService";
+import MessageQueueLabelRuleService from "../../../../Server/Services/MessageQueueLabelRuleService";
+import MessageQueueService from "../../../../Server/Services/MessageQueueService";
 import PodmanHostFeedService from "../../../../Server/Services/PodmanHostFeedService";
 import PodmanHostLabelRuleEngineService from "../../../../Server/Services/PodmanHostLabelRuleEngineService";
 import PodmanHostLabelRuleService from "../../../../Server/Services/PodmanHostLabelRuleService";
@@ -53,6 +56,8 @@ import BaseModel from "../../../../Models/DatabaseModels/DatabaseBaseModel/Datab
 import IncidentEpisode from "../../../../Models/DatabaseModels/IncidentEpisode";
 import IncidentEpisodeLabelRule from "../../../../Models/DatabaseModels/IncidentEpisodeLabelRule";
 import Label from "../../../../Models/DatabaseModels/Label";
+import MessageQueue from "../../../../Models/DatabaseModels/MessageQueue";
+import MessageQueueLabelRule from "../../../../Models/DatabaseModels/MessageQueueLabelRule";
 import PodmanHost from "../../../../Models/DatabaseModels/PodmanHost";
 import PodmanHostLabelRule from "../../../../Models/DatabaseModels/PodmanHostLabelRule";
 import ProxmoxCluster from "../../../../Models/DatabaseModels/ProxmoxCluster";
@@ -182,6 +187,11 @@ interface LabelEngineCase {
   severity: SeverityFields | null;
   expectedRuleSelect: Record<string, unknown>;
   expectedResourceSelect: Record<string, unknown>;
+  /*
+   * What a re-reading engine reads back, when it matches on more than
+   * the name, description and labels (a queue's messaging system).
+   */
+  reReadSelect?: Record<string, unknown> | undefined;
   // Mocks the feed write (and anything it reads) and returns the write spy.
   mockFeed: (() => jest.SpyInstance) | null;
   feedResourceIdKey: string | null;
@@ -537,6 +547,44 @@ const cases: Array<LabelEngineCase> = [
     mockFeed: null,
     feedResourceIdKey: null,
   }),
+  labelEngineCase<MessageQueue, MessageQueueLabelRule>({
+    name: "MessageQueueLabelRuleEngineService",
+    engine: MessageQueueLabelRuleEngineService,
+    applyOnCreate: (resource: MessageQueue): Promise<void> => {
+      return MessageQueueLabelRuleEngineService.applyRulesToMessageQueue(
+        resource,
+      );
+    },
+    ruleService: MessageQueueLabelRuleService as unknown as RuleReadService,
+    resourceService: MessageQueueService as unknown as ResourceService,
+    resourceModel: MessageQueue,
+    textField: "name",
+    patternField: "messageQueueNamePattern",
+    labelMatchField: "messageQueueLabels",
+    matchesHandedResource: false,
+    syncsInMemoryLabels: true,
+    severity: null,
+    expectedRuleSelect: {
+      _id: true,
+      name: true,
+      criteria: true,
+      messageQueueLabels: { _id: true },
+      messageQueueNamePattern: true,
+      messageQueueDescriptionPattern: true,
+      messageQueueSystemPattern: true,
+      labelsToAdd: { _id: true },
+    },
+    expectedResourceSelect: IDS_ONLY_RESOURCE_SELECT,
+    // The system pattern matches on the queue's messaging system too.
+    reReadSelect: {
+      name: true,
+      description: true,
+      messagingSystem: true,
+      labels: { _id: true },
+    },
+    mockFeed: null,
+    feedResourceIdKey: null,
+  }),
   labelEngineCase<AlertEpisode, AlertEpisodeLabelRule>({
     name: "AlertEpisodeLabelRuleEngineService",
     engine: AlertEpisodeLabelRuleEngineService,
@@ -844,7 +892,7 @@ describe("label rule engines (group B) - applying a rule to existing resources",
       cases.map((c: LabelEngineCase) => {
         return c.name;
       }),
-    ).toHaveLength(12);
+    ).toHaveLength(13);
   });
 
   describe.each(cases)("$name", (c: LabelEngineCase) => {
@@ -1168,11 +1216,13 @@ describe("label rule engines (group B) - applying a rule to existing resources",
       expect(writes).toHaveLength(1);
       const reReadArgs: any = reRead.mock.calls[0]![0];
       expect(reReadArgs.id.toString()).toBe(RESOURCE_ID.toString());
-      expect(reReadArgs.select).toEqual({
-        name: true,
-        description: true,
-        labels: { _id: true },
-      });
+      expect(reReadArgs.select).toEqual(
+        c.reReadSelect || {
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+      );
     });
 
     /*