@oneuptime/common 12.0.7 → 12.0.9

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

@@ -1,11 +1,16 @@
 import LogAggregationService, {
+  AnalyticsRequest,
   FacetRequest,
+  HistogramRequest,
 } from "../../../Server/Services/LogAggregationService";
+import LogDatabaseService from "../../../Server/Services/LogService";
+import { Results } from "../../../Server/Services/AnalyticsDatabaseService";
 import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
 import AnalyticsTableName from "../../../Types/AnalyticsDatabase/AnalyticsTableName";
+import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
-import { describe, expect, test } from "@jest/globals";
+import { describe, expect, test, afterEach, jest } from "@jest/globals";
 
 describe("LogAggregationService", () => {
   const defaultRequest: FacetRequest = {
@@ -133,3 +138,232 @@ describe("LogAggregationService", () => {
     ]);
   });
 });
+
+describe("LogAggregationService sessionIds filter", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  const projectId: ObjectID = ObjectID.generate();
+  const startTime: Date = new Date("2026-03-01T00:00:00.000Z");
+  const endTime: Date = new Date("2026-03-12T00:00:00.000Z");
+
+  const SESSION_IN_PREDICATE: RegExp =
+    /AND sessionId IN \(\{p\d+:Array\(String\)\}\)/;
+
+  const buildHistogramStatement: (
+    overrides?: Partial<HistogramRequest>,
+  ) => Statement = (overrides: Partial<HistogramRequest> = {}): Statement => {
+    return (LogAggregationService as any).buildHistogramStatement({
+      projectId,
+      startTime,
+      endTime,
+      bucketSizeInMinutes: 60,
+      ...overrides,
+    });
+  };
+
+  const analyticsRequest: (
+    overrides: Partial<AnalyticsRequest>,
+  ) => AnalyticsRequest = (
+    overrides: Partial<AnalyticsRequest>,
+  ): AnalyticsRequest => {
+    return {
+      projectId,
+      startTime,
+      endTime,
+      bucketSizeInMinutes: 60,
+      chartType: "timeseries",
+      aggregation: "count",
+      ...overrides,
+    };
+  };
+
+  /*
+   * Stub the ClickHouse boundary while capturing every Statement handed
+   * to executeQuery, so the async read paths (export, context) can be
+   * exercised without a database.
+   */
+  const stubAndCaptureStatements: (
+    rows: Array<JSONObject>,
+  ) => Array<Statement> = (rows: Array<JSONObject>): Array<Statement> => {
+    const captured: Array<Statement> = [];
+    const fakeResult: Results = {
+      json: () => {
+        return Promise.resolve({ data: rows });
+      },
+    } as unknown as Results;
+
+    jest
+      .spyOn(LogDatabaseService, "executeQuery")
+      .mockImplementation((statement: Statement | string): Promise<Results> => {
+        captured.push(statement as Statement);
+        return Promise.resolve(fakeResult);
+      });
+
+    return captured;
+  };
+
+  test("histogram statement threads sessionIds as a parameterized IN predicate", () => {
+    const statement: Statement = buildHistogramStatement({
+      sessionIds: ["sess-1", "sess-2"],
+    });
+
+    expect(statement.query).toMatch(SESSION_IN_PREDICATE);
+    expect(Object.values(statement.query_params)).toContainEqual([
+      "sess-1",
+      "sess-2",
+    ]);
+  });
+
+  test("histogram statement omits the predicate when sessionIds is absent or empty", () => {
+    expect(buildHistogramStatement().query).not.toContain("sessionId");
+    expect(buildHistogramStatement({ sessionIds: [] }).query).not.toContain(
+      "sessionId",
+    );
+  });
+
+  test("sessionIds combine with traceIds and spanIds", () => {
+    const statement: Statement = buildHistogramStatement({
+      traceIds: ["trace-1"],
+      spanIds: ["span-1"],
+      sessionIds: ["sess-1"],
+    });
+
+    expect(statement.query).toMatch(
+      /AND traceId IN \(\{p\d+:Array\(String\)\}\)/,
+    );
+    expect(statement.query).toMatch(
+      /AND spanId IN \(\{p\d+:Array\(String\)\}\)/,
+    );
+    expect(statement.query).toMatch(SESSION_IN_PREDICATE);
+  });
+
+  test("injection-shaped session ids stay out of the query text", () => {
+    const evilSessionId: string = "') OR 1=1; DROP TABLE Log; --";
+    const statement: Statement = buildHistogramStatement({
+      sessionIds: [evilSessionId],
+    });
+
+    expect(statement.query).not.toContain(evilSessionId);
+    expect(Object.values(statement.query_params)).toContainEqual([
+      evilSessionId,
+    ]);
+  });
+
+  test("facet statement threads sessionIds", () => {
+    const statement: Statement = (
+      LogAggregationService as any
+    ).buildFacetStatement({
+      projectId,
+      startTime,
+      endTime,
+      facetKey: "severityText",
+      limit: 10,
+      sessionIds: ["sess-1"],
+    } as FacetRequest);
+
+    expect(statement.query).toMatch(SESSION_IN_PREDICATE);
+    expect(Object.values(statement.query_params)).toContainEqual(["sess-1"]);
+  });
+
+  test("analytics timeseries statement threads sessionIds", () => {
+    const statement: Statement = (
+      LogAggregationService as any
+    ).buildAnalyticsTimeseriesStatement(
+      analyticsRequest({ sessionIds: ["sess-1"] }),
+    );
+
+    expect(statement.query).toMatch(SESSION_IN_PREDICATE);
+    expect(Object.values(statement.query_params)).toContainEqual(["sess-1"]);
+  });
+
+  test("analytics toplist statement threads sessionIds", () => {
+    const statement: Statement = (
+      LogAggregationService as any
+    ).buildAnalyticsTopListStatement(
+      analyticsRequest({
+        chartType: "toplist",
+        groupBy: ["severityText"],
+        sessionIds: ["sess-1"],
+      }),
+    );
+
+    expect(statement.query).toMatch(SESSION_IN_PREDICATE);
+    expect(Object.values(statement.query_params)).toContainEqual(["sess-1"]);
+  });
+
+  test("analytics table statement threads sessionIds", () => {
+    const statement: Statement = (
+      LogAggregationService as any
+    ).buildAnalyticsTableStatement(
+      analyticsRequest({
+        chartType: "table",
+        groupBy: ["severityText"],
+        sessionIds: ["sess-1"],
+      }),
+    );
+
+    expect(statement.query).toMatch(SESSION_IN_PREDICATE);
+    expect(Object.values(statement.query_params)).toContainEqual(["sess-1"]);
+  });
+
+  test("getExportLogs threads sessionIds into the export read", async () => {
+    const captured: Array<Statement> = stubAndCaptureStatements([]);
+
+    await LogAggregationService.getExportLogs({
+      projectId,
+      startTime,
+      endTime,
+      limit: 100,
+      sessionIds: ["sess-1"],
+    });
+
+    expect(captured.length).toBe(1);
+    expect(captured[0]!.query).toMatch(SESSION_IN_PREDICATE);
+    expect(Object.values(captured[0]!.query_params)).toContainEqual(["sess-1"]);
+  });
+
+  test("getLogContext scopes both context reads to the session", async () => {
+    const captured: Array<Statement> = stubAndCaptureStatements([]);
+
+    await LogAggregationService.getLogContext({
+      projectId,
+      primaryEntityId: ObjectID.generate(),
+      time: startTime,
+      logId: "log-1",
+      count: 5,
+      sessionIds: ["sess-1"],
+    });
+
+    expect(captured.length).toBe(2);
+    for (const statement of captured) {
+      // The predicate must land in the WHERE clause, before the ORDER BY.
+      expect(statement.query).toMatch(
+        /AND sessionId IN \(\{p\d+:Array\(String\)\}\)[\s\S]*ORDER BY time/,
+      );
+      expect(Object.values(statement.query_params)).toContainEqual(["sess-1"]);
+    }
+  });
+
+  test("getLogContext without sessionIds emits no sessionId predicate", async () => {
+    const captured: Array<Statement> = stubAndCaptureStatements([]);
+
+    await LogAggregationService.getLogContext({
+      projectId,
+      primaryEntityId: ObjectID.generate(),
+      time: startTime,
+      logId: "log-1",
+      count: 5,
+    });
+
+    expect(captured.length).toBe(2);
+    for (const statement of captured) {
+      expect(statement.query).not.toContain("sessionId");
+      // The LIMIT restructure must keep the ordering clauses intact.
+      expect(statement.query).toMatch(
+        /ORDER BY time (DESC|ASC), timeUnixNano (DESC|ASC)[\s\S]*LIMIT \{p\d+:Int32\}/,
+      );
+    }
+  });
+});

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

@@ -0,0 +1,231 @@
+import MetricAggregationService, {
+  MetricForTraceItem,
+  MetricsForTraceRequest,
+} from "../../../Server/Services/MetricAggregationService";
+import MetricService from "../../../Server/Services/MetricService";
+import { Results } from "../../../Server/Services/AnalyticsDatabaseService";
+import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import AnalyticsTableName from "../../../Types/AnalyticsDatabase/AnalyticsTableName";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, afterEach, jest } from "@jest/globals";
+
+describe("MetricAggregationService.getMetricsForTrace statement building", () => {
+  type BuildMetricsForTraceStatement = (
+    request: MetricsForTraceRequest,
+  ) => Statement;
+
+  /*
+   * The builder is private but pure — reaching it through a cast keeps
+   * predicate generation testable without a ClickHouse round trip (same
+   * pattern as the LogAggregationService facet tests).
+   */
+  const buildMetricsForTraceStatement: BuildMetricsForTraceStatement = (
+    MetricAggregationService as unknown as {
+      buildMetricsForTraceStatement: BuildMetricsForTraceStatement;
+    }
+  ).buildMetricsForTraceStatement.bind(MetricAggregationService);
+
+  const projectId: ObjectID = ObjectID.generate();
+
+  test("selects the exemplar columns from the Metric table, scoped and ordered", () => {
+    const statement: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: "trace-1",
+    });
+
+    expect(statement.query).toContain("toFloat64(value) AS value");
+    expect(statement.query).toContain("toString(primaryEntityId) AS serviceId");
+    expect(statement.query).toContain("attributes");
+    expect(statement.query).toMatch(/WHERE projectId = \{p\d+:String\}/);
+    expect(statement.query).toMatch(/AND traceId = \{p\d+:String\}/);
+    expect(statement.query).toContain("retentionDate >= now()");
+    expect(statement.query).toMatch(/ORDER BY time ASC LIMIT \{p\d+:Int32\}/);
+    expect(Object.values(statement.query_params)).toContain(
+      AnalyticsTableName.Metric,
+    );
+    expect(Object.values(statement.query_params)).toContain(
+      projectId.toString(),
+    );
+    expect(Object.values(statement.query_params)).toContain("trace-1");
+    // Default row cap.
+    expect(Object.values(statement.query_params)).toContain(500);
+  });
+
+  test("spanIds add a parameterized IN predicate; empty array behaves as absent", () => {
+    const withSpans: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: "trace-1",
+      spanIds: ["span-a", "span-b"],
+    });
+
+    expect(withSpans.query).toMatch(
+      /AND spanId IN \(\{p\d+:Array\(String\)\}\)/,
+    );
+    expect(Object.values(withSpans.query_params)).toContainEqual([
+      "span-a",
+      "span-b",
+    ]);
+
+    const emptySpans: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: "trace-1",
+      spanIds: [],
+    });
+
+    expect(emptySpans.query).not.toContain("spanId IN");
+
+    const absentSpans: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: "trace-1",
+    });
+
+    expect(absentSpans.query).not.toContain("spanId IN");
+  });
+
+  test("caller limits are honored below the cap and clamped above it", () => {
+    const small: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: "trace-1",
+      limit: 10,
+    });
+    expect(Object.values(small.query_params)).toContain(10);
+
+    const oversized: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: "trace-1",
+      limit: 999999,
+    });
+    expect(Object.values(oversized.query_params)).toContain(500);
+    expect(Object.values(oversized.query_params)).not.toContain(999999);
+  });
+
+  test("injection-shaped values stay out of the query text", () => {
+    const evilTraceId: string = "') UNION SELECT * FROM system.tables --";
+    const evilSpanId: string = "x'); DROP TABLE Metric; --";
+
+    const statement: Statement = buildMetricsForTraceStatement({
+      projectId,
+      traceId: evilTraceId,
+      spanIds: [evilSpanId],
+    });
+
+    expect(statement.query).not.toContain(evilTraceId);
+    expect(statement.query).not.toContain(evilSpanId);
+    expect(Object.values(statement.query_params)).toContain(evilTraceId);
+    expect(Object.values(statement.query_params)).toContainEqual([evilSpanId]);
+  });
+});
+
+describe("MetricAggregationService.getMetricsForTrace", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  const projectId: ObjectID = ObjectID.generate();
+
+  /*
+   * Stub the ClickHouse boundary while capturing the Statement handed to
+   * executeQuery, so the read path can be exercised without a database.
+   */
+  const stubAndCaptureStatements: (
+    rows: Array<JSONObject>,
+  ) => Array<Statement> = (rows: Array<JSONObject>): Array<Statement> => {
+    const captured: Array<Statement> = [];
+    const fakeResult: Results = {
+      json: () => {
+        return Promise.resolve({ data: rows });
+      },
+    } as unknown as Results;
+
+    jest
+      .spyOn(MetricService, "executeQuery")
+      .mockImplementation((statement: Statement | string): Promise<Results> => {
+        captured.push(statement as Statement);
+        return Promise.resolve(fakeResult);
+      });
+
+    return captured;
+  };
+
+  test("maps rows into typed items, coercing ClickHouse string numerics", async () => {
+    const captured: Array<Statement> = stubAndCaptureStatements([
+      {
+        name: "http.server.duration",
+        time: "2026-03-01 00:00:00",
+        value: "12.5",
+        spanId: "span-1",
+        serviceId: "svc-1",
+        attributes: { "http.route": "/api" },
+      },
+      {
+        name: "queue.depth",
+        time: "2026-03-01 00:00:05",
+        value: 3,
+        spanId: "span-2",
+        serviceId: "svc-2",
+        attributes: {},
+      },
+    ]);
+
+    const items: Array<MetricForTraceItem> =
+      await MetricAggregationService.getMetricsForTrace({
+        projectId,
+        traceId: "trace-1",
+        spanIds: ["span-1", "span-2"],
+      });
+
+    expect(captured.length).toBe(1);
+    expect(items).toStrictEqual([
+      {
+        name: "http.server.duration",
+        time: "2026-03-01 00:00:00",
+        value: 12.5,
+        spanId: "span-1",
+        serviceId: "svc-1",
+        attributes: { "http.route": "/api" },
+      },
+      {
+        name: "queue.depth",
+        time: "2026-03-01 00:00:05",
+        value: 3,
+        spanId: "span-2",
+        serviceId: "svc-2",
+        attributes: {},
+      },
+    ]);
+  });
+
+  test("degrades missing row fields to safe defaults", async () => {
+    stubAndCaptureStatements([{ name: "orphan.metric" }]);
+
+    const items: Array<MetricForTraceItem> =
+      await MetricAggregationService.getMetricsForTrace({
+        projectId,
+        traceId: "trace-1",
+      });
+
+    expect(items).toStrictEqual([
+      {
+        name: "orphan.metric",
+        time: "",
+        value: 0,
+        spanId: "",
+        serviceId: "",
+        attributes: {},
+      },
+    ]);
+  });
+
+  test("returns an empty list when the trace stamped no exemplars", async () => {
+    stubAndCaptureStatements([]);
+
+    const items: Array<MetricForTraceItem> =
+      await MetricAggregationService.getMetricsForTrace({
+        projectId,
+        traceId: "trace-without-exemplars",
+      });
+
+    expect(items).toStrictEqual([]);
+  });
+});

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

@@ -1,4 +1,4 @@
-import TelemetryEntity, {
+import InventoryItem, {
   ExtractedEntity,
   keyForContainer,
 } from "../../../Server/Utils/Telemetry/TelemetryEntity";
@@ -15,7 +15,7 @@ import { describe, expect, test } from "@jest/globals";
  * uses (keyForHost / keyForKubernetesCluster / keyForContainer /
  * keyForService) against the ingest side that stamps the scalar
  * entity-key columns the per-entity rollup MVs group by
- * (TelemetryEntity.extractEntities -> serviceEntityKey / hostEntityKey /
+ * (InventoryItem.extractEntities -> serviceEntityKey / hostEntityKey /
  * k8sClusterEntityKey / containerEntityKey on MetricItemV3; the MVs copy
  * the stamped column verbatim — `WHERE <key> != '' GROUP BY ... <key>`).
  *
@@ -30,16 +30,21 @@ describe("entity-MV routing keys — parity with ingest-stamped scalar entity ke
   const projectId: string = "proj-123";
 
   /*
-   * A resource carrying all four routable identities at once, with
-   * casing/whitespace drift to exercise canonicalization.
+   * Keep standalone-host and Kubernetes fixtures separate: Kubernetes
+   * resources can carry an SDK-detected host.name (often the pod hostname),
+   * but ingest deliberately does not stamp that as a Host entity.
    */
-  const attributes: Record<string, string> = {
+  const standaloneHostAttributes: Record<string, string> = {
     "host.name": "Web-Server-01 ",
-    "k8s.cluster.name": "Prod-EU-1",
     "container.id": "ABC123def456",
     "service.name": "Checkout",
   };
 
+  const kubernetesAttributes: Record<string, string> = {
+    ...standaloneHostAttributes,
+    "k8s.cluster.name": "Prod-EU-1",
+  };
+
   type FirstOfTypeFunction = (
     entities: Array<ExtractedEntity>,
     entityType: EntityType,
@@ -61,15 +66,30 @@ describe("entity-MV routing keys — parity with ingest-stamped scalar entity ke
     );
   };
 
-  test("each routable read-side key byte-matches the stamped scalar column", () => {
-    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+  test("standalone-host read-side keys byte-match the stamped scalar columns", () => {
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId,
-      attributes,
+      attributes: standaloneHostAttributes,
     });
 
     expect(firstOfType(entities, EntityType.Host)).toBe(
       keyForHost(projectId, "Web-Server-01 "),
     );
+    expect(firstOfType(entities, EntityType.Container)).toBe(
+      keyForContainer(projectId, "ABC123def456"),
+    );
+    expect(firstOfType(entities, EntityType.Service)).toBe(
+      keyForService(projectId, "Checkout"),
+    );
+  });
+
+  test("Kubernetes read-side keys byte-match while the phantom Host key stays absent", () => {
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
+      projectId,
+      attributes: kubernetesAttributes,
+    });
+
+    expect(firstOfType(entities, EntityType.Host)).toBe("");
     expect(firstOfType(entities, EntityType.KubernetesCluster)).toBe(
       keyForKubernetesCluster(projectId, "Prod-EU-1"),
     );
@@ -82,32 +102,51 @@ describe("entity-MV routing keys — parity with ingest-stamped scalar entity ke
   });
 
   test("read-side keys canonicalize exactly like ingest (spelling drift lands on one rollup stream)", () => {
-    const drifted: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
-      projectId,
-      attributes: {
-        "host.name": "web-server-01",
-        "k8s.cluster.name": " prod-eu-1 ",
-        "container.id": "abc123DEF456",
-        "service.name": "  checkout",
-      },
-    });
+    const driftedStandaloneHost: Array<ExtractedEntity> =
+      InventoryItem.extractEntities({
+        projectId,
+        attributes: {
+          "host.name": "web-server-01",
+          "container.id": "abc123DEF456",
+          "service.name": "  checkout",
+        },
+      });
 
-    expect(firstOfType(drifted, EntityType.Host)).toBe(
+    expect(firstOfType(driftedStandaloneHost, EntityType.Host)).toBe(
       keyForHost(projectId, "Web-Server-01 "),
     );
-    expect(firstOfType(drifted, EntityType.KubernetesCluster)).toBe(
+    expect(firstOfType(driftedStandaloneHost, EntityType.Container)).toBe(
+      keyForContainer(projectId, "ABC123def456"),
+    );
+    expect(firstOfType(driftedStandaloneHost, EntityType.Service)).toBe(
+      keyForService(projectId, "Checkout"),
+    );
+
+    const driftedKubernetes: Array<ExtractedEntity> =
+      InventoryItem.extractEntities({
+        projectId,
+        attributes: {
+          "host.name": "web-server-01",
+          "k8s.cluster.name": " prod-eu-1 ",
+          "container.id": "abc123DEF456",
+          "service.name": "  checkout",
+        },
+      });
+
+    expect(firstOfType(driftedKubernetes, EntityType.Host)).toBe("");
+    expect(firstOfType(driftedKubernetes, EntityType.KubernetesCluster)).toBe(
       keyForKubernetesCluster(projectId, "Prod-EU-1"),
     );
-    expect(firstOfType(drifted, EntityType.Container)).toBe(
+    expect(firstOfType(driftedKubernetes, EntityType.Container)).toBe(
       keyForContainer(projectId, "ABC123def456"),
     );
-    expect(firstOfType(drifted, EntityType.Service)).toBe(
+    expect(firstOfType(driftedKubernetes, EntityType.Service)).toBe(
       keyForService(projectId, "Checkout"),
     );
   });
 
   test("host stamping matches the live-ClickHouse-verified vector from EntityKeySqlParity", () => {
-    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId: "proj-123",
       attributes: { "host.name": "Web-Server-01 " },
     });
@@ -117,7 +156,7 @@ describe("entity-MV routing keys — parity with ingest-stamped scalar entity ke
   });
 
   test("service.namespace forks the stamped key — the bare-name key MUST NOT be assumed (registry required)", () => {
-    const namespaced: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const namespaced: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId,
       attributes: {
         "service.name": "checkout",
@@ -139,7 +178,7 @@ describe("entity-MV routing keys — parity with ingest-stamped scalar entity ke
 
   test("a blank namespace is not identity-bearing on either side", () => {
     const blankNamespace: Array<ExtractedEntity> =
-      TelemetryEntity.extractEntities({
+      InventoryItem.extractEntities({
         projectId,
         attributes: {
           "service.name": "checkout",
@@ -155,19 +194,31 @@ describe("entity-MV routing keys — parity with ingest-stamped scalar entity ke
     );
   });
 
-  test("entityKeys membership (the entityScope raw predicate) contains every routable key", () => {
-    const membershipKeys: Array<string> = TelemetryEntity.extractEntityKeys({
+  test("standalone-host entityKeys membership contains the Host key", () => {
+    const membershipKeys: Array<string> = InventoryItem.extractEntityKeys({
+      projectId,
+      attributes: standaloneHostAttributes,
+    });
+
+    expect(membershipKeys).toContain(keyForHost(projectId, "Web-Server-01 "));
+  });
+
+  test("Kubernetes entityKeys membership contains typed keys and excludes the phantom Host key", () => {
+    const membershipKeys: Array<string> = InventoryItem.extractEntityKeys({
       projectId,
-      attributes,
+      attributes: kubernetesAttributes,
     });
 
     for (const key of [
-      keyForHost(projectId, "Web-Server-01 "),
       keyForKubernetesCluster(projectId, "Prod-EU-1"),
       keyForContainer(projectId, "ABC123def456"),
       keyForService(projectId, "Checkout"),
     ]) {
       expect(membershipKeys).toContain(key);
     }
+
+    expect(membershipKeys).not.toContain(
+      keyForHost(projectId, "Web-Server-01 "),
+    );
   });
 });