@oneuptime/common 10.4.10 → 10.4.12

package/Server/Services/LogAggregationService.ts

@@ -8,6 +8,7 @@ import Includes from "../../Types/BaseDatabase/Includes";
 import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { DbJSONResponse, Results } from "./AnalyticsDatabaseService";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 
 export interface HistogramBucket {
   time: string;
@@ -92,6 +93,19 @@ export class LogAggregationService {
     "traceId",
     "spanId",
   ]);
+  /*
+   * Virtual facet keys that don't correspond to real ClickHouse columns —
+   * they all read out of `serviceId` filtered by `serviceType`. The
+   * discriminator was added so host / docker host / k8s cluster telemetry
+   * could reuse the `serviceId` slot instead of synthesising phantom
+   * Service rows; these facets surface each resource type independently.
+   */
+  private static readonly RESOURCE_FACET_KEYS: Map<string, ServiceType> =
+    new Map([
+      ["hostId", ServiceType.Host],
+      ["dockerHostId", ServiceType.DockerHost],
+      ["kubernetesClusterId", ServiceType.KubernetesCluster],
+    ]);
   private static readonly ATTRIBUTE_KEY_PATTERN: RegExp = /^[a-zA-Z0-9._:/-]+$/;
   private static readonly MAX_FACET_KEY_LENGTH: number = 256;
 
@@ -192,13 +206,25 @@ export class LogAggregationService {
 
     LogAggregationService.validateFacetKey(request.facetKey);
 
-    const isTopLevelColumn: boolean = LogAggregationService.isTopLevelColumn(
-      request.facetKey,
-    );
+    const resourceServiceType: ServiceType | undefined =
+      LogAggregationService.RESOURCE_FACET_KEYS.get(request.facetKey);
+    const isResourceFacet: boolean = resourceServiceType !== undefined;
+    const isTopLevelColumn: boolean =
+      isResourceFacet ||
+      LogAggregationService.isTopLevelColumn(request.facetKey);
 
     const statement: Statement = new Statement();
 
-    if (isTopLevelColumn) {
+    if (isResourceFacet) {
+      /*
+       * Virtual facet — group serviceId values whose row carries the
+       * matching ServiceType discriminator (Host / DockerHost /
+       * KubernetesCluster).
+       */
+      statement.append(
+        SQL`SELECT toString(serviceId) AS val, count() AS cnt FROM ${LogAggregationService.TABLE_NAME}`,
+      );
+    } else if (isTopLevelColumn) {
       statement.append(
         SQL`SELECT toString(${request.facetKey}) AS val, count() AS cnt FROM ${LogAggregationService.TABLE_NAME}`,
       );
@@ -224,7 +250,26 @@ export class LogAggregationService {
       }}`,
     );
 
-    if (!isTopLevelColumn) {
+    if (isResourceFacet) {
+      statement.append(
+        SQL` AND serviceType = ${{
+          type: TableColumnType.Text,
+          value: resourceServiceType as string,
+        }}`,
+      );
+    } else if (request.facetKey === "serviceId") {
+      /*
+       * Constrain the canonical Services facet to rows that actually
+       * belong to a Service. NULL / empty serviceType covers legacy
+       * rows ingested before the discriminator existed.
+       */
+      statement.append(
+        SQL` AND (serviceType = '' OR serviceType = ${{
+          type: TableColumnType.Text,
+          value: ServiceType.OpenTelemetry as string,
+        }})`,
+      );
+    } else if (!isTopLevelColumn) {
       statement.append(
         SQL` AND JSONHas(attributes, ${{
           type: TableColumnType.Text,
@@ -944,7 +989,10 @@ export class LogAggregationService {
       throw new BadDataException("Invalid facetKey");
     }
 
-    if (LogAggregationService.isTopLevelColumn(facetKey)) {
+    if (
+      LogAggregationService.isTopLevelColumn(facetKey) ||
+      LogAggregationService.RESOURCE_FACET_KEYS.has(facetKey)
+    ) {
       return;
     }
 

package/Server/Services/OnCallDutyPolicyEscalationRuleScheduleService.ts

@@ -77,6 +77,9 @@ export class Service extends DatabaseService<Model> {
     const userOnSchedule: ObjectID | null =
       await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
         createdModel.onCallDutyPolicyScheduleId,
+        {
+          onCallDutyPolicyId: createdModel.onCallDutyPolicy?.id || undefined,
+        },
       );
 
     if (!userOnSchedule) {
@@ -277,6 +280,9 @@ export class Service extends DatabaseService<Model> {
       const userOnSchedule: ObjectID | null =
         await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
           deletedItem.onCallDutyPolicyScheduleId!,
+          {
+            onCallDutyPolicyId: deletedItem.onCallDutyPolicy?.id || undefined,
+          },
         );
 
       if (!userOnSchedule) {

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -460,6 +460,7 @@ export class Service extends DatabaseService<Model> {
       const userIdInSchedule: ObjectID | null =
         await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
           scheduleRule.onCallDutyPolicyScheduleId!,
+          { onCallDutyPolicyId: options.onCallPolicyId },
         );
 
       if (!userIdInSchedule) {

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -1052,17 +1052,28 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
     scheduleUserIds: Array<ObjectID>;
     windowStart: Date;
     windowEnd: Date;
+    currentOnCallDutyPolicyId?: ObjectID | undefined;
   }): Promise<Array<UserOverrideRecord>> {
     if (data.scheduleUserIds.length === 0) {
       return [];
     }
 
+    /*
+     * When a policy context is provided, include overrides scoped to that
+     * policy plus global overrides. Without a policy context (e.g. schedule
+     * roster refresh, dashboard preview, incoming-call routing), only global
+     * overrides apply — a policy-specific override from one policy must not
+     * affect schedule resolution for a different policy.
+     */
     const overrides: Array<OnCallDutyPolicyUserOverride> =
       await OnCallDutyPolicyUserOverrideService.findBy({
         query: {
           projectId: data.projectId,
           startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
           endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+          onCallDutyPolicyId: data.currentOnCallDutyPolicyId
+            ? QueryHelper.equalToOrNull(data.currentOnCallDutyPolicyId)
+            : QueryHelper.isNull(),
         },
         select: {
           startsAt: true,
@@ -1106,6 +1117,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   public async getEventByIndexInSchedule(data: {
     scheduleId: ObjectID;
     getNumberOfEvents: number; // which event would you like to get. First event, second event, etc.
+    onCallDutyPolicyId?: ObjectID | undefined;
   }): Promise<Array<CalendarEvent>> {
     logger.debug(
       "getEventByIndexInSchedule called with data: " + JSON.stringify(data),
@@ -1169,12 +1181,14 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
           scheduleUserIds,
           windowStart: currentStartTime,
           windowEnd: currentEndTime,
+          currentOnCallDutyPolicyId: data.onCallDutyPolicyId,
         });
 
       if (overrides.length > 0) {
         events = UserOverrideUtil.applyOverridesToEvents({
           events,
           overrides,
+          currentOnCallDutyPolicyId: data.onCallDutyPolicyId?.toString(),
         });
       }
     }
@@ -1189,6 +1203,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   @CaptureSpan()
   public async getCurrentUserIdInSchedule(
     scheduleId: ObjectID,
+    options?: { onCallDutyPolicyId?: ObjectID | undefined } | undefined,
   ): Promise<ObjectID | null> {
     const { layerProps, projectId, scheduleUserIds } =
       await this.getScheduleLayerProps({
@@ -1223,12 +1238,14 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
           scheduleUserIds,
           windowStart: currentStartTime,
           windowEnd: currentEndTime,
+          currentOnCallDutyPolicyId: options?.onCallDutyPolicyId,
         });
 
       if (overrides.length > 0) {
         events = UserOverrideUtil.applyOverridesToEvents({
           events,
           overrides,
+          currentOnCallDutyPolicyId: options?.onCallDutyPolicyId?.toString(),
         });
       }
     }

package/Server/Services/OpenTelemetryIngestService.ts

@@ -16,6 +16,13 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import logger from "../Utils/Logger";
 import TelemetryRetentionConfig from "../../Types/Telemetry/TelemetryRetentionConfig";
+import ServiceType from "../../Types/Telemetry/ServiceType";
+import Host from "../../Models/DatabaseModels/Host";
+import DockerHost from "../../Models/DatabaseModels/DockerHost";
+import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
+import HostService from "./HostService";
+import DockerHostService from "./DockerHostService";
+import KubernetesClusterService from "./KubernetesClusterService";
 
 export enum OtelAggregationTemporality {
   Cumulative = "AGGREGATION_TEMPORALITY_CUMULATIVE",
@@ -25,6 +32,14 @@ export enum OtelAggregationTemporality {
 export interface TelemetryServiceMetadata {
   serviceName: string;
   serviceId: ObjectID;
+  /*
+   * Discriminator stamped on every analytics row so the read side
+   * knows which Postgres table the `serviceId` actually points at
+   * (real Service, Host, DockerHost, KubernetesCluster, Monitor, …).
+   * Defaults to OpenTelemetry for legacy ingest paths that go through
+   * `telemetryServiceFromName`.
+   */
+  serviceType: ServiceType;
   dataRententionInDays: number;
   serviceRetentionConfig: TelemetryRetentionConfig | null;
   serviceRetentionInDays: number | null;
@@ -166,6 +181,7 @@ export default class OTelIngestService {
       return {
         serviceName: data.serviceName,
         serviceId: svc.id!,
+        serviceType: ServiceType.OpenTelemetry,
         dataRententionInDays:
           serviceLevelRetention || projectContext.projectRetentionInDays,
         serviceRetentionConfig: svc.telemetryRetentionConfig ?? null,
@@ -225,6 +241,122 @@ export default class OTelIngestService {
 
     return buildMetadata(service);
   }
+
+  /*
+   * Builds a TelemetryServiceMetadata for a non-Service resource —
+   * Host, DockerHost, KubernetesCluster, Monitor. These resources
+   * own telemetry directly via their own Postgres id (stamped into
+   * the analytics row's `serviceId` column) and do not have a paired
+   * Service row. Per-resource retention overrides (when set on the
+   * Host / DockerHost / KubernetesCluster row) are honoured here so
+   * the resource owner can keep host telemetry longer/shorter than
+   * the project default. Monitor / unknown resource types fall back
+   * to the project retention.
+   */
+  @CaptureSpan()
+  public static async buildResourceMetadataForNonService(data: {
+    serviceName: string;
+    resourceId: ObjectID;
+    serviceType: ServiceType;
+    projectId: ObjectID;
+  }): Promise<TelemetryServiceMetadata> {
+    const projectContext: ProjectRetentionContext =
+      await this.getProjectRetentionContext(data.projectId);
+
+    const resourceRetention: {
+      retainTelemetryDataForDays: number | null;
+      telemetryRetentionConfig: TelemetryRetentionConfig | null;
+    } = await this.getResourceRetention(data.resourceId, data.serviceType);
+
+    return {
+      serviceName: data.serviceName,
+      serviceId: data.resourceId,
+      serviceType: data.serviceType,
+      dataRententionInDays:
+        resourceRetention.retainTelemetryDataForDays ||
+        projectContext.projectRetentionInDays,
+      serviceRetentionConfig: resourceRetention.telemetryRetentionConfig,
+      serviceRetentionInDays: resourceRetention.retainTelemetryDataForDays,
+      projectRetentionConfig: projectContext.projectRetentionConfig,
+      projectRetentionInDays: projectContext.projectRetentionInDays,
+    };
+  }
+
+  /*
+   * Look up per-resource retention overrides for non-Service telemetry.
+   * One small SELECT per batch — the caller caches the resulting
+   * TelemetryServiceMetadata under `serviceDictionary[serviceName]`
+   * so steady-state ingest skips this lookup after the first row.
+   */
+  @CaptureSpan()
+  private static async getResourceRetention(
+    resourceId: ObjectID,
+    serviceType: ServiceType,
+  ): Promise<{
+    retainTelemetryDataForDays: number | null;
+    telemetryRetentionConfig: TelemetryRetentionConfig | null;
+  }> {
+    try {
+      if (serviceType === ServiceType.Host) {
+        const host: Host | null = await HostService.findOneById({
+          id: resourceId,
+          select: {
+            retainTelemetryDataForDays: true,
+            telemetryRetentionConfig: true,
+          },
+          props: { isRoot: true },
+        });
+        return {
+          retainTelemetryDataForDays: host?.retainTelemetryDataForDays ?? null,
+          telemetryRetentionConfig: host?.telemetryRetentionConfig ?? null,
+        };
+      }
+      if (serviceType === ServiceType.DockerHost) {
+        const dockerHost: DockerHost | null =
+          await DockerHostService.findOneById({
+            id: resourceId,
+            select: {
+              retainTelemetryDataForDays: true,
+              telemetryRetentionConfig: true,
+            },
+            props: { isRoot: true },
+          });
+        return {
+          retainTelemetryDataForDays:
+            dockerHost?.retainTelemetryDataForDays ?? null,
+          telemetryRetentionConfig:
+            dockerHost?.telemetryRetentionConfig ?? null,
+        };
+      }
+      if (serviceType === ServiceType.KubernetesCluster) {
+        const cluster: KubernetesCluster | null =
+          await KubernetesClusterService.findOneById({
+            id: resourceId,
+            select: {
+              retainTelemetryDataForDays: true,
+              telemetryRetentionConfig: true,
+            },
+            props: { isRoot: true },
+          });
+        return {
+          retainTelemetryDataForDays:
+            cluster?.retainTelemetryDataForDays ?? null,
+          telemetryRetentionConfig: cluster?.telemetryRetentionConfig ?? null,
+        };
+      }
+    } catch (err) {
+      logger.warn(
+        `Per-resource retention lookup failed for ${serviceType} ${resourceId.toString()}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+    return {
+      retainTelemetryDataForDays: null,
+      telemetryRetentionConfig: null,
+    };
+  }
+
   @CaptureSpan()
   public static getMetricFromDatapoint(data: {
     dbMetric: Metric;

package/Server/Services/TelemetryIngestionKeyService.ts

@@ -1,11 +1,30 @@
 import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import ObjectID from "../../Types/ObjectID";
 import Model from "../../Models/DatabaseModels/TelemetryIngestionKey";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
+import { createHash } from "crypto";
+
+/*
+ * 60s is the worst-case staleness on any single API node after a key is
+ * revoked from the dashboard. We invalidate in-process immediately on
+ * delete/update; this TTL is the upper bound for *other* processes.
+ */
+const POSITIVE_TTL_MS: number = 60 * 1000;
+/*
+ * Short TTL on misses so an invalid-token flood can't pin entries in the
+ * bounded cache for long while still absorbing repeat hits.
+ */
+const NEGATIVE_TTL_MS: number = 10 * 1000;
 
 export class Service extends DatabaseService<Model> {
+  private projectIdCache: InMemoryTTLCache<string | null> =
+    new InMemoryTTLCache(10_000);
+
   public constructor() {
     super(Model);
   }
@@ -20,6 +39,76 @@ export class Service extends DatabaseService<Model> {
 
     return { createBy, carryForward: null };
   }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    /*
+     * We don't know which secretKey(s) are being deleted without an extra
+     * query; clear the whole cache. Key deletes are rare so this is cheap.
+     */
+    this.projectIdCache.clear();
+    return { deleteBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    /*
+     * Same reasoning as onBeforeDelete. secretKey is not user-editable today
+     * but projectId could change, so be conservative.
+     */
+    this.projectIdCache.clear();
+    return { updateBy, carryForward: null };
+  }
+
+  /**
+   * Resolve an ingestion token to its projectId, with a short-lived
+   * in-process cache to keep the hot ingest path off Postgres. Returns null
+   * for unknown, malformed, or revoked tokens (also cached, for a shorter
+   * TTL).
+   */
+  @CaptureSpan()
+  public async getProjectIdFromSecretKey(
+    secretKey: string,
+  ): Promise<ObjectID | null> {
+    const cacheKey: string = createHash("sha256")
+      .update(secretKey)
+      .digest("hex");
+
+    const cached: string | null | undefined = this.projectIdCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached === null ? null : new ObjectID(cached);
+    }
+
+    let secretKeyObjectId: ObjectID;
+    try {
+      secretKeyObjectId = new ObjectID(secretKey);
+    } catch {
+      this.projectIdCache.set(cacheKey, null, NEGATIVE_TTL_MS);
+      return null;
+    }
+
+    const token: Model | null = await this.findOneBy({
+      query: { secretKey: secretKeyObjectId },
+      select: { projectId: true },
+      props: { isRoot: true },
+    });
+
+    const projectId: ObjectID | undefined = token?.projectId as
+      | ObjectID
+      | undefined;
+
+    if (!projectId) {
+      this.projectIdCache.set(cacheKey, null, NEGATIVE_TTL_MS);
+      return null;
+    }
+
+    this.projectIdCache.set(cacheKey, projectId.toString(), POSITIVE_TTL_MS);
+    return projectId;
+  }
 }
 
 export default new Service();

package/Server/Services/TraceAggregationService.ts

@@ -9,6 +9,7 @@ import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { DbJSONResponse, Results } from "./AnalyticsDatabaseService";
 import logger from "../Utils/Logger";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 
 export interface HistogramBucket {
   time: string;
@@ -69,6 +70,17 @@ export class TraceAggregationService {
     "statusCode",
     "isRootSpan",
   ]);
+  /*
+   * Virtual facet keys — same scheme as LogAggregationService. The
+   * `serviceId` slot is reused for host / docker host / k8s cluster ids,
+   * disambiguated by the `serviceType` discriminator.
+   */
+  private static readonly RESOURCE_FACET_KEYS: Map<string, ServiceType> =
+    new Map([
+      ["hostId", ServiceType.Host],
+      ["dockerHostId", ServiceType.DockerHost],
+      ["kubernetesClusterId", ServiceType.KubernetesCluster],
+    ]);
   private static readonly ATTRIBUTE_KEY_PATTERN: RegExp = /^[a-zA-Z0-9._:/-]+$/;
   private static readonly MAX_FACET_KEY_LENGTH: number = 256;
 
@@ -156,14 +168,25 @@ export class TraceAggregationService {
       TraceAggregationService.validateFacetKey(facetKey);
     }
 
+    const resourceKeys: Array<string> = request.facetKeys.filter(
+      (key: string): boolean => {
+        return TraceAggregationService.RESOURCE_FACET_KEYS.has(key);
+      },
+    );
     const topLevelKeys: Array<string> = request.facetKeys.filter(
       (key: string): boolean => {
-        return TraceAggregationService.isTopLevelColumn(key);
+        return (
+          TraceAggregationService.isTopLevelColumn(key) &&
+          !TraceAggregationService.RESOURCE_FACET_KEYS.has(key)
+        );
       },
     );
     const attributeKeys: Array<string> = request.facetKeys.filter(
       (key: string): boolean => {
-        return !TraceAggregationService.isTopLevelColumn(key);
+        return (
+          !TraceAggregationService.isTopLevelColumn(key) &&
+          !TraceAggregationService.RESOURCE_FACET_KEYS.has(key)
+        );
       },
     );
 
@@ -171,6 +194,13 @@ export class TraceAggregationService {
     if (topLevelKeys.length > 0) {
       selectColumns.push(...topLevelKeys);
     }
+    if (resourceKeys.length > 0) {
+      // Virtual facets read out of serviceId disambiguated by serviceType.
+      if (!selectColumns.includes("serviceId")) {
+        selectColumns.push("serviceId");
+      }
+      selectColumns.push("serviceType");
+    }
     if (attributeKeys.length > 0) {
       selectColumns.push("attributes");
     }
@@ -244,6 +274,27 @@ export class TraceAggregationService {
         map.set(value, (map.get(value) || 0) + 1);
       }
 
+      if (resourceKeys.length > 0) {
+        const rowServiceType: string =
+          row["serviceType"] === undefined || row["serviceType"] === null
+            ? ""
+            : String(row["serviceType"]);
+        const rowServiceId: unknown = row["serviceId"];
+        if (rowServiceId !== undefined && rowServiceId !== null) {
+          const value: string = String(rowServiceId);
+          if (value.length > 0) {
+            for (const key of resourceKeys) {
+              const expected: ServiceType | undefined =
+                TraceAggregationService.RESOURCE_FACET_KEYS.get(key);
+              if (expected && rowServiceType === expected) {
+                const map: Map<string, number> = counts[key]!;
+                map.set(value, (map.get(value) || 0) + 1);
+              }
+            }
+          }
+        }
+      }
+
       if (attributeKeys.length > 0) {
         const attrs: unknown = row["attributes"];
         let parsed: Record<string, unknown> | null = null;
@@ -368,13 +419,20 @@ export class TraceAggregationService {
 
     TraceAggregationService.validateFacetKey(request.facetKey);
 
-    const isTopLevelColumn: boolean = TraceAggregationService.isTopLevelColumn(
-      request.facetKey,
-    );
+    const resourceServiceType: ServiceType | undefined =
+      TraceAggregationService.RESOURCE_FACET_KEYS.get(request.facetKey);
+    const isResourceFacet: boolean = resourceServiceType !== undefined;
+    const isTopLevelColumn: boolean =
+      isResourceFacet ||
+      TraceAggregationService.isTopLevelColumn(request.facetKey);
 
     const statement: Statement = new Statement();
 
-    if (isTopLevelColumn) {
+    if (isResourceFacet) {
+      statement.append(
+        SQL`SELECT toString(serviceId) AS val, count() AS cnt FROM ${TraceAggregationService.TABLE_NAME}`,
+      );
+    } else if (isTopLevelColumn) {
       statement.append(
         SQL`SELECT toString(${request.facetKey}) AS val, count() AS cnt FROM ${TraceAggregationService.TABLE_NAME}`,
       );
@@ -400,7 +458,21 @@ export class TraceAggregationService {
       }}`,
     );
 
-    if (!isTopLevelColumn) {
+    if (isResourceFacet) {
+      statement.append(
+        SQL` AND serviceType = ${{
+          type: TableColumnType.Text,
+          value: resourceServiceType as string,
+        }}`,
+      );
+    } else if (request.facetKey === "serviceId") {
+      statement.append(
+        SQL` AND (serviceType = '' OR serviceType = ${{
+          type: TableColumnType.Text,
+          value: ServiceType.OpenTelemetry as string,
+        }})`,
+      );
+    } else if (!isTopLevelColumn) {
       statement.append(
         SQL` AND JSONHas(attributes, ${{
           type: TableColumnType.Text,
@@ -539,7 +611,10 @@ export class TraceAggregationService {
       throw new BadDataException("Invalid facetKey");
     }
 
-    if (TraceAggregationService.isTopLevelColumn(facetKey)) {
+    if (
+      TraceAggregationService.isTopLevelColumn(facetKey) ||
+      TraceAggregationService.RESOURCE_FACET_KEYS.has(facetKey)
+    ) {
       return;
     }
 

package/Server/Utils/Monitor/MonitorMetricUtil.ts

@@ -5,10 +5,8 @@ import MetricService from "../../Services/MetricService";
 import GlobalConfigService from "../../Services/GlobalConfigService";
 import GlobalConfig from "../../../Models/DatabaseModels/GlobalConfig";
 import DataToProcess from "./DataToProcess";
-import {
-  MetricPointType,
-  ServiceType,
-} from "../../../Models/AnalyticsModels/Metric";
+import { MetricPointType } from "../../../Models/AnalyticsModels/Metric";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
 import MetricType from "../../../Models/DatabaseModels/MetricType";
 import BasicInfrastructureMetrics, {
   NetworkInterfaceMetrics,

package/Server/Utils/Telemetry/Telemetry.ts

@@ -135,6 +135,44 @@ export default class TelemetryUtil {
     };
   }
 
+  /*
+   * Cross-cutting resource stamps. Spread alongside the service stamp on
+   * every analytics row so a single ClickHouse query can find "all
+   * telemetry from host X" / "from docker host Y" / "from cluster Z"
+   * regardless of which Service the row primarily belongs to. Without
+   * these, host context would only be queryable as the raw OTel
+   * `resource.host.name` string with no stable id link.
+   */
+  public static getAttributesForHostIdAndHostName(data: {
+    hostId: ObjectID;
+    hostName: string;
+  }): Dictionary<AttributeType> {
+    return {
+      "oneuptime.host.id": data.hostId.toString(),
+      "oneuptime.host.name": data.hostName,
+    };
+  }
+
+  public static getAttributesForDockerHostIdAndHostName(data: {
+    dockerHostId: ObjectID;
+    hostName: string;
+  }): Dictionary<AttributeType> {
+    return {
+      "oneuptime.docker.host.id": data.dockerHostId.toString(),
+      "oneuptime.docker.host.name": data.hostName,
+    };
+  }
+
+  public static getAttributesForKubernetesClusterIdAndName(data: {
+    kubernetesClusterId: ObjectID;
+    clusterName: string;
+  }): Dictionary<AttributeType> {
+    return {
+      "oneuptime.kubernetes.cluster.id": data.kubernetesClusterId.toString(),
+      "oneuptime.kubernetes.cluster.name": data.clusterName,
+    };
+  }
+
   @CaptureSpan()
   public static getAttributes(data: {
     prefixKeysWithString: string;