@oneuptime/common 10.4.9 → 10.4.11

package/Models/DatabaseModels/KubernetesCluster.ts

@@ -19,6 +19,7 @@ import UniqueColumnBy from "../../Types/Database/UniqueColumnBy";
 import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
+import TelemetryRetentionConfig from "../../Types/Telemetry/TelemetryRetentionConfig";
 import {
   Column,
   Entity,
@@ -725,4 +726,86 @@ export default class KubernetesCluster extends BaseModel {
     },
   })
   public labels?: Array<Label> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateKubernetesCluster,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.Number,
+    title: "Retain Telemetry Data For Days",
+    description:
+      "Number of days to retain telemetry data for this Kubernetes cluster. Leave blank to use the project-wide default.",
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: true,
+    unique: false,
+  })
+  public retainTelemetryDataForDays?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateKubernetesCluster,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    required: false,
+    title: "Telemetry Data Retention Overrides",
+    description:
+      "Per-pillar retention overrides for this Kubernetes cluster (logs by severity, traces by status, metrics, profiles). Unset fields fall back to the cluster default, then the project's retention settings.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public telemetryRetentionConfig?: TelemetryRetentionConfig = undefined;
 }

package/Server/Infrastructure/Postgres/SchemaMigrations/1779199346010-AddTelemetryRetentionConfig.ts

@@ -3,7 +3,7 @@ import { MigrationInterface, QueryRunner } from "typeorm";
 export class AddTelemetryRetentionConfig1779199346010
   implements MigrationInterface
 {
-  name = "AddTelemetryRetentionConfig1779199346010";
+  public name: string = "AddTelemetryRetentionConfig1779199346010";
 
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.query(

package/Server/Infrastructure/Postgres/SchemaMigrations/1779277271302-DropServiceDependencyTable.ts

@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+import CaptureSpan from "../../../Utils/Telemetry/CaptureSpan";
+
+export class DropServiceDependencyTable1779277271302
+  implements MigrationInterface
+{
+  public name = "DropServiceDependencyTable1779277271302";
+
+  @CaptureSpan()
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS "ServiceDependency" CASCADE`);
+  }
+
+  @CaptureSpan()
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "ServiceDependency" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "serviceId" uuid NOT NULL, "dependencyServiceId" uuid NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_f4c8003faa6daec34a5b97f88e8" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3e2a1ef7e8795a46c2e2e9955c" ON "ServiceDependency" ("projectId")`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3af01e69f3e28ae56a968bbd81" ON "ServiceDependency" ("serviceId")`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c2562045902370ec46091924fc" ON "ServiceDependency" ("dependencyServiceId")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ServiceDependency" ADD CONSTRAINT "FK_3e2a1ef7e8795a46c2e2e9955c2" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ServiceDependency" ADD CONSTRAINT "FK_3af01e69f3e28ae56a968bbd812" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ServiceDependency" ADD CONSTRAINT "FK_c2562045902370ec46091924fc8" FOREIGN KEY ("dependencyServiceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ServiceDependency" ADD CONSTRAINT "FK_cc8c8d41106bebab21d1c69e129" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ServiceDependency" ADD CONSTRAINT "FK_feb830e4e4f8259a871105b16e8" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779282769946-AddTelemetryRetentionToHostDockerKubernetes.ts

@@ -0,0 +1,50 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddTelemetryRetentionToHostDockerKubernetes1779282769946
+  implements MigrationInterface
+{
+  public name: string =
+    "AddTelemetryRetentionToHostDockerKubernetes1779282769946";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Host" ADD "retainTelemetryDataForDays" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Host" ADD "telemetryRetentionConfig" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerHost" ADD "retainTelemetryDataForDays" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerHost" ADD "telemetryRetentionConfig" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "retainTelemetryDataForDays" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "telemetryRetentionConfig" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "telemetryRetentionConfig"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "retainTelemetryDataForDays"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerHost" DROP COLUMN "telemetryRetentionConfig"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerHost" DROP COLUMN "retainTelemetryDataForDays"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Host" DROP COLUMN "telemetryRetentionConfig"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Host" DROP COLUMN "retainTelemetryDataForDays"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -338,6 +338,8 @@ import { AddOnCallDutyPolicyScheduleOwners1778929624633 } from "./1778929624633-
 import { AddOnCallIncomingCallOwnersAndRules1778931537020 } from "./1778931537020-AddOnCallIncomingCallOwnersAndRules";
 import { IncreaseSmtpUsernameLength1779125489830 } from "./1779125489830-IncreaseSmtpUsernameLength";
 import { AddTelemetryRetentionConfig1779199346010 } from "./1779199346010-AddTelemetryRetentionConfig";
+import { DropServiceDependencyTable1779277271302 } from "./1779277271302-DropServiceDependencyTable";
+import { AddTelemetryRetentionToHostDockerKubernetes1779282769946 } from "./1779282769946-AddTelemetryRetentionToHostDockerKubernetes";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -679,4 +681,6 @@ export default [
   AddOnCallIncomingCallOwnersAndRules1778931537020,
   IncreaseSmtpUsernameLength1779125489830,
   AddTelemetryRetentionConfig1779199346010,
+  DropServiceDependencyTable1779277271302,
+  AddTelemetryRetentionToHostDockerKubernetes1779282769946,
 ];

package/Server/Services/AlertService.ts

@@ -38,10 +38,8 @@ import MetricService from "./MetricService";
 import GlobalConfigService from "./GlobalConfigService";
 import GlobalConfig from "../../Models/DatabaseModels/GlobalConfig";
 import OneUptimeDate from "../../Types/Date";
-import Metric, {
-  MetricPointType,
-  ServiceType,
-} from "../../Models/AnalyticsModels/Metric";
+import Metric, { MetricPointType } from "../../Models/AnalyticsModels/Metric";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 import AlertMetricType from "../../Types/Alerts/AlertMetricType";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";

package/Server/Services/IncidentService.ts

@@ -42,10 +42,8 @@ import MetricService from "./MetricService";
 import GlobalConfigService from "./GlobalConfigService";
 import GlobalConfig from "../../Models/DatabaseModels/GlobalConfig";
 import IncidentMetricType from "../../Types/Incident/IncidentMetricType";
-import Metric, {
-  MetricPointType,
-  ServiceType,
-} from "../../Models/AnalyticsModels/Metric";
+import Metric, { MetricPointType } from "../../Models/AnalyticsModels/Metric";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 import OneUptimeDate from "../../Types/Date";
 import TelemetryUtil from "../Utils/Telemetry/Telemetry";
 import logger, { LogAttributes } from "../Utils/Logger";

package/Server/Services/Index.ts

@@ -161,7 +161,6 @@ import WorkflowLogService from "./WorkflowLogService";
 import WorkflowService from "./WorkflowService";
 import WorkflowVariablesService from "./WorkflowVariableService";
 import AnalyticsBaseModel from "../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
-import ServiceDependencyService from "./ServiceDependencyService";
 import TelemetryExceptionService from "./TelemetryExceptionService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
 import ScheduledMaintenanceTemplateService from "./ScheduledMaintenanceTemplateService";
@@ -388,7 +387,6 @@ const services: Array<BaseService> = [
   ServiceService,
   ServiceOwnerTeamService,
   ServiceOwnerUserService,
-  ServiceDependencyService,
   ServiceMonitorService,
   ServiceCodeRepositoryService,
 

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/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/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;
     }