@oneuptime/common 10.5.9 → 10.5.17

package/Models/AnalyticsModels/ExceptionInstance.ts

@@ -15,7 +15,7 @@ import { SpanStatus } from "./Span";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 
 @OperationalResource()
-@OwnedThrough("serviceId", Service)
+@OwnedThrough("serviceId", Service, { includeProjectScope: true })
 export default class ExceptionInstance extends AnalyticsBaseModel {
   public constructor() {
     const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({

package/Models/AnalyticsModels/Log.ts

@@ -16,7 +16,7 @@ import Service from "../DatabaseModels/Service";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 
 @OperationalResource()
-@OwnedThrough("serviceId", Service)
+@OwnedThrough("serviceId", Service, { includeProjectScope: true })
 export default class Log extends AnalyticsBaseModel {
   public constructor() {
     const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({

package/Models/AnalyticsModels/Metric.ts

@@ -28,7 +28,7 @@ export enum MetricPointType {
 }
 
 @OperationalResource()
-@OwnedThrough("serviceId", Service)
+@OwnedThrough("serviceId", Service, { includeProjectScope: true })
 export default class Metric extends AnalyticsBaseModel {
   public constructor() {
     const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({

package/Models/AnalyticsModels/Profile.ts

@@ -15,7 +15,7 @@ import Service from "../DatabaseModels/Service";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 
 @OperationalResource()
-@OwnedThrough("serviceId", Service)
+@OwnedThrough("serviceId", Service, { includeProjectScope: true })
 export default class Profile extends AnalyticsBaseModel {
   public constructor() {
     const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({

package/Models/AnalyticsModels/ProfileSample.ts

@@ -15,7 +15,7 @@ import Service from "../DatabaseModels/Service";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 
 @OperationalResource()
-@OwnedThrough("serviceId", Service)
+@OwnedThrough("serviceId", Service, { includeProjectScope: true })
 export default class ProfileSample extends AnalyticsBaseModel {
   public constructor() {
     const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({

package/Models/AnalyticsModels/Span.ts

@@ -47,7 +47,7 @@ export interface SpanLink {
 }
 
 @OperationalResource()
-@OwnedThrough("serviceId", Service)
+@OwnedThrough("serviceId", Service, { includeProjectScope: true })
 export default class Span extends AnalyticsBaseModel {
   public constructor() {
     const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({

package/Models/DatabaseModels/TelemetryException.ts

@@ -17,9 +17,13 @@ import TenantColumn from "../../Types/Database/TenantColumn";
 import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import DatabaseBaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Service from "./Service";
+import Host from "./Host";
+import DockerHost from "./DockerHost";
+import KubernetesCluster from "./KubernetesCluster";
 
 @EnableDocumentation()
 @CanAccessIfCanReadOn("service")
@@ -60,7 +64,16 @@ import Service from "./Service";
   tableDescription:
     "List of all Telemetry Exceptions created for the telemetry service for this OneUptime project and it's status.",
 })
-@OwnedThrough("serviceId", Service)
+/*
+ * serviceId is polymorphic (see the column below) — it may reference a
+ * Service, Host, DockerHost or KubernetesCluster, or be the projectId for
+ * unattributed (Unknown) telemetry. Owned scope unions ownership across all
+ * of those resource types, and includeProjectScope lets in-project users
+ * see the unattributed bucket (which has no owner resource).
+ */
+@OwnedThrough("serviceId", [Service, Host, DockerHost, KubernetesCluster], {
+  includeProjectScope: true,
+})
 @Entity({
   name: "TelemetryException",
 })
@@ -150,6 +163,15 @@ export default class TelemetryException extends DatabaseBaseModel {
   })
   public projectId?: ObjectID = undefined;
 
+  /*
+   * serviceId is polymorphic (disambiguated by serviceType, mirroring the
+   * ClickHouse ExceptionInstance rows): it can be a real Service, a Host /
+   * DockerHost / KubernetesCluster id, or the projectId for unattributed
+   * (Unknown) telemetry. There is intentionally NO @ManyToOne(Service)
+   * relation — a Service join would only resolve OpenTelemetry rows and
+   * silently null out everything else. The read side resolves serviceId +
+   * serviceType to a resource per type (TelemetryServiceUtil) instead.
+   */
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,
@@ -172,27 +194,21 @@ export default class TelemetryException extends DatabaseBaseModel {
       Permission.EditTelemetryException,
     ],
   })
+  @Index()
   @TableColumn({
-    manyToOneRelationColumn: "serviceId",
-    type: TableColumnType.Entity,
-    modelType: Service,
-    title: "Service",
-    description: "Relation to Service Resource in which this object belongs",
+    type: TableColumnType.ObjectID,
+    required: true,
+    title: "Service ID",
+    description:
+      "ID of the resource this exception belongs to (Service / Host / DockerHost / KubernetesCluster, or the projectId for unattributed telemetry — disambiguated by serviceType).",
     example: "d4e5f6a7-b8c9-0123-def1-234567890123",
   })
-  @ManyToOne(
-    () => {
-      return Service;
-    },
-    {
-      eager: false,
-      nullable: true,
-      onDelete: "CASCADE",
-      orphanedRowAction: "nullify",
-    },
-  )
-  @JoinColumn({ name: "serviceId" })
-  public service?: Service = undefined;
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public serviceId?: ObjectID = undefined;
 
   @ColumnAccessControl({
     create: [
@@ -210,26 +226,22 @@ export default class TelemetryException extends DatabaseBaseModel {
       Permission.TelemetryViewer,
       Permission.ReadTelemetryException,
     ],
-    update: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.EditTelemetryException,
-    ],
+    update: [],
   })
-  @Index()
   @TableColumn({
-    type: TableColumnType.ObjectID,
-    required: true,
-    title: "Service ID",
-    description: "ID of your Service resource where this object belongs",
-    example: "d4e5f6a7-b8c9-0123-def1-234567890123",
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Service Type",
+    description:
+      "Resource type that produced this exception (e.g. OpenTelemetry service, Host, DockerHost, KubernetesCluster, or Unknown for unattributed telemetry).",
+    example: "OpenTelemetry",
   })
   @Column({
-    type: ColumnType.ObjectID,
-    nullable: false,
-    transformer: ObjectID.getDatabaseTransformer(),
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
   })
-  public serviceId?: ObjectID = undefined;
+  public serviceType?: ServiceType = undefined;
 
   @ColumnAccessControl({
     create: [

package/Models/DatabaseModels/TelemetryUsageBilling.ts

@@ -15,6 +15,7 @@ import TenantColumn from "../../Types/Database/TenantColumn";
 import Decimal from "../../Types/Decimal";
 import IconProp from "../../Types/Icon/IconProp";
 import ProductType from "../../Types/MeteredPlan/ProductType";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
@@ -270,8 +271,16 @@ export default class TelemetryUsageBilling extends BaseModel {
     {
       eager: false,
       nullable: true,
-      onDelete: "CASCADE",
-      orphanedRowAction: "nullify",
+      /*
+       * No DB-level foreign key. Telemetry that arrives without a
+       * service.name is metered against a synthetic "unattributed"
+       * bucket whose serviceId is the projectId (ServiceType.Unknown),
+       * which has no matching Service row — a FK would reject those
+       * billing rows. The relation is kept for read-side joins; it
+       * resolves to null for the unattributed bucket and the UI renders
+       * a synthetic "Unknown Service" in its place.
+       */
+      createForeignKeyConstraints: false,
     },
   )
   @JoinColumn({ name: "serviceId" })
@@ -301,6 +310,30 @@ export default class TelemetryUsageBilling extends BaseModel {
   })
   public serviceId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ManageProjectBilling,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Service Type",
+    description:
+      "Resource type that produced this telemetry (e.g. OpenTelemetry service, Host, DockerHost, KubernetesCluster, or Unknown for unattributed telemetry).",
+    example: "OpenTelemetry",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public serviceType?: ServiceType = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Server/API/AIAgentDataAPI.ts

@@ -1,6 +1,7 @@
 import AIAgentService from "../Services/AIAgentService";
 import LlmProviderService from "../Services/LlmProviderService";
 import TelemetryExceptionService from "../Services/TelemetryExceptionService";
+import ServiceService from "../Services/ServiceService";
 import ServiceCodeRepositoryService from "../Services/ServiceCodeRepositoryService";
 import CodeRepositoryService from "../Services/CodeRepositoryService";
 import AIAgentTaskPullRequestService from "../Services/AIAgentTaskPullRequestService";
@@ -15,6 +16,7 @@ import Response from "../Utils/Response";
 import AIAgent from "../../Models/DatabaseModels/AIAgent";
 import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
 import TelemetryException from "../../Models/DatabaseModels/TelemetryException";
+import Service from "../../Models/DatabaseModels/Service";
 import ServiceCodeRepository from "../../Models/DatabaseModels/ServiceCodeRepository";
 import CodeRepository from "../../Models/DatabaseModels/CodeRepository";
 import AIAgentTaskPullRequest from "../../Models/DatabaseModels/AIAgentTaskPullRequest";
@@ -174,11 +176,7 @@ export default class AIAgentDataAPI {
                 exceptionType: true,
                 fingerprint: true,
                 serviceId: true,
-                service: {
-                  _id: true,
-                  name: true,
-                  description: true,
-                },
+                serviceType: true,
               },
               props: {
                 isRoot: true,
@@ -198,6 +196,26 @@ export default class AIAgentDataAPI {
             getLogAttributesFromRequest(req as any),
           );
 
+          /*
+           * serviceId is polymorphic — resolve the Service only when it is
+           * a real Service. findOneById returns null for Host / DockerHost /
+           * KubernetesCluster / unattributed serviceIds (they aren't
+           * Services), preserving the previous "name only for real
+           * services" behaviour without the dropped ORM relation.
+           */
+          const exceptionService: Service | null = exception.serviceId
+            ? await ServiceService.findOneById({
+                id: exception.serviceId,
+                select: {
+                  name: true,
+                  description: true,
+                },
+                props: {
+                  isRoot: true,
+                },
+              })
+            : null;
+
           return Response.sendJsonObjectResponse(req, res, {
             exception: {
               id: exception._id?.toString(),
@@ -209,8 +227,8 @@ export default class AIAgentDataAPI {
             service: exception.serviceId
               ? {
                   id: exception.serviceId.toString(),
-                  name: exception.service?.name,
-                  description: exception.service?.description,
+                  name: exceptionService?.name,
+                  description: exceptionService?.description,
                 }
               : null,
           });

package/Server/API/TelemetryExceptionAPI.ts

@@ -1,5 +1,4 @@
 import TelemetryException from "../../Models/DatabaseModels/TelemetryException";
-import TelemetryServiceModel from "../../Models/DatabaseModels/Service";
 import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
 import AIAgentTaskTelemetryException from "../../Models/DatabaseModels/AIAgentTaskTelemetryException";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -211,8 +210,13 @@ export default class TelemetryExceptionAPI extends BaseAPI<
 
     const serviceSummariesJson: JSONArray = summary.serviceSummaries.map(
       (entry: DashboardServiceSummary): JSONObject => {
+        /*
+         * serviceId is polymorphic; the client resolves the display name
+         * per serviceType (no Service relation to serialize anymore).
+         */
         return {
-          service: BaseModel.toJSON(entry.service, TelemetryServiceModel),
+          serviceId: entry.serviceId,
+          serviceType: entry.serviceType,
           unresolvedCount: entry.unresolvedCount,
           totalOccurrences: entry.totalOccurrences,
         };

package/Server/Infrastructure/Postgres/SchemaMigrations/1780381124553-MigrationName.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Drop the foreign key from TelemetryUsageBilling.serviceId -> Service.
+ *
+ * Telemetry ingested without an OTel service.name is metered against a
+ * synthetic "unattributed" bucket whose serviceId is the projectId
+ * (ServiceType.Unknown). That id has no matching Service row, so the FK
+ * would reject the billing row. serviceId stays a required column; it is
+ * just no longer constrained to the Service table (it is polymorphic,
+ * mirroring the analytics telemetry rows). The TypeORM relation is kept
+ * for read-side joins and resolves to null for the unattributed bucket.
+ */
+export class MigrationName1780381124553 implements MigrationInterface {
+  public name = "MigrationName1780381124553";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" DROP CONSTRAINT IF EXISTS "FK_b9f49cd8318a35757fc843ee900"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" ADD CONSTRAINT "FK_b9f49cd8318a35757fc843ee900" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1780382837019-MigrationName.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Add TelemetryUsageBilling.serviceType — the resource-type discriminator
+ * for a usage row (OpenTelemetry / Host / DockerHost / KubernetesCluster /
+ * Unknown). Lets the usage breakdown attribute ingestion to the kind of
+ * resource that produced it, now that non-Service telemetry is metered.
+ * Nullable; legacy rows (all real Services) are treated as OpenTelemetry.
+ */
+export class MigrationName1780382837019 implements MigrationInterface {
+  public name = "MigrationName1780382837019";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" ADD COLUMN IF NOT EXISTS "serviceType" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" DROP COLUMN IF EXISTS "serviceType"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1780387560604-MigrationName.ts

@@ -0,0 +1,47 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1780387560604 implements MigrationInterface {
+  public name = "MigrationName1780387560604";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "SmsLog" DROP CONSTRAINT "FK_SmsLog_userOnCallLogTimelineId"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_SmsLog_userOnCallLogTimelineId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_77bd357cbaad40a136a36f5f1e" ON "SmsLog" ("userOnCallLogTimelineId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "SmsLog" ADD CONSTRAINT "FK_77bd357cbaad40a136a36f5f1ed" FOREIGN KEY ("userOnCallLogTimelineId") REFERENCES "UserOnCallLogTimeline"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "SmsLog" DROP CONSTRAINT "FK_77bd357cbaad40a136a36f5f1ed"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_77bd357cbaad40a136a36f5f1e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_SmsLog_userOnCallLogTimelineId" ON "SmsLog" ("userOnCallLogTimelineId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "SmsLog" ADD CONSTRAINT "FK_SmsLog_userOnCallLogTimelineId" FOREIGN KEY ("userOnCallLogTimelineId") REFERENCES "UserOnCallLogTimeline"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1780388219225-MigrationName.ts

@@ -0,0 +1,34 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Make TelemetryException.serviceId polymorphic:
+ *  - Drop the foreign key to Service. An exception's serviceId can be a
+ *    Service, a Host / DockerHost / KubernetesCluster id, or the projectId
+ *    for unattributed (Unknown) telemetry — a FK to Service rejected every
+ *    non-Service exception and forced ingest to skip them.
+ *  - Add a serviceType discriminator (OpenTelemetry / Host / DockerHost /
+ *    KubernetesCluster / Unknown) so the Issues UI can attribute each issue
+ *    to the kind of resource that produced it. Nullable; legacy rows (all
+ *    real Services) are treated as OpenTelemetry on read.
+ */
+export class MigrationName1780388219225 implements MigrationInterface {
+  public name = "MigrationName1780388219225";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP CONSTRAINT IF EXISTS "FK_08a0cfa9f184257b1e57da4cf50"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD COLUMN IF NOT EXISTS "serviceType" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN IF EXISTS "serviceType"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD CONSTRAINT "FK_08a0cfa9f184257b1e57da4cf50" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

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

@@ -361,6 +361,10 @@ import { AddTransportTypeToProjectSmtpConfig1779975064262 } from "./177997506426
 import { AddSmtpTransportTypeToGlobalConfig1779976190561 } from "./1779976190561-AddSmtpTransportTypeToGlobalConfig";
 import { MigrationName1779980428744 } from "./1779980428744-MigrationName";
 import { AddDeliveryTrackingToSmsLog1780317745887 } from "./1780317745887-AddDeliveryTrackingToSmsLog";
+import { MigrationName1780381124553 } from "./1780381124553-MigrationName";
+import { MigrationName1780382837019 } from "./1780382837019-MigrationName";
+import { MigrationName1780387560604 } from "./1780387560604-MigrationName";
+import { MigrationName1780388219225 } from "./1780388219225-MigrationName";
 
 export default [
   InitialMigration,
@@ -726,4 +730,8 @@ export default [
   AddSmtpTransportTypeToGlobalConfig1779976190561,
   MigrationName1779980428744,
   AddDeliveryTrackingToSmsLog1780317745887,
+  MigrationName1780381124553,
+  MigrationName1780382837019,
+  MigrationName1780387560604,
+  MigrationName1780388219225,
 ];

package/Server/Infrastructure/QueueWorker.ts

@@ -8,6 +8,12 @@ import {
 import { Worker } from "bullmq";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import AppMetrics from "../Utils/Telemetry/AppMetrics";
+import TelemetryContext from "../Utils/Telemetry/TelemetryContext";
+import Telemetry, {
+  Span,
+  SpanException,
+  SpanStatusCode,
+} from "../Utils/Telemetry";
 import Redis from "./Redis";
 
 export default class QueueWorker {
@@ -45,7 +51,40 @@ export default class QueueWorker {
       let outcome: "success" | "failure" | "timeout" = "success";
 
       try {
-        await onJobInQueue(job);
+        /*
+         * Seed a telemetry-context scope for this job so every span and log it
+         * produces inherits the queue/job name plus any tenant identifiers
+         * carried in the job payload (projectId, monitorId, incidentId, ...).
+         */
+        await TelemetryContext.runWithContext(
+          {
+            queueName: queueName,
+            jobName: job.name || "unknown",
+            ...TelemetryContext.pickKnownAttributes(job.data),
+          },
+          () => {
+            /*
+             * Wrap the job in an explicit root span so every background job has
+             * a consistent, named trace root that carries the seeded context —
+             * the @CaptureSpan service calls it makes become children of this.
+             */
+            return Telemetry.startActiveSpan<Promise<void>>({
+              name: `worker.job ${queueName}/${job.name || "unknown"}`,
+              fn: async (span: Span): Promise<void> => {
+                try {
+                  await onJobInQueue(job);
+                  span.setStatus({ code: SpanStatusCode.OK });
+                } catch (err) {
+                  span.recordException(err as SpanException);
+                  span.setStatus({ code: SpanStatusCode.ERROR });
+                  throw err;
+                } finally {
+                  span.end();
+                }
+              },
+            });
+          },
+        );
       } catch (err) {
         outcome =
           err instanceof TimeoutException ||

package/Server/Services/AnalyticsDatabaseService.ts

@@ -366,6 +366,93 @@ export default class AnalyticsDatabaseService<
     return await this._findBy(findBy);
   }
 
+  /**
+   * Group telemetry rows by (serviceId, serviceType) for a project over a
+   * time window, returning the row count and an estimate of the ingested
+   * byte size (ClickHouse `byteSize(*)`, the uncompressed in-memory size of
+   * each row's columns). This is the enumeration source for usage billing:
+   * a single aggregation scan surfaces EVERY resource that emitted
+   * telemetry — real Services, Hosts, Docker hosts, Kubernetes clusters,
+   * Monitors and unattributed (serviceId = projectId) — without needing a
+   * Postgres row per resource. The caller decides which serviceTypes to
+   * bill and how to attribute retention.
+   */
+  @CaptureSpan()
+  public async groupTelemetryUsageByService(data: {
+    projectId: ObjectID;
+    timestampColumnName: keyof TBaseModel | string;
+    startDate: Date;
+    endDate: Date;
+  }): Promise<
+    Array<{
+      serviceId: string;
+      serviceType: string | null;
+      rowCount: number;
+      estimatedBytes: number;
+    }>
+  > {
+    const timestampColumnName: string = data.timestampColumnName.toString();
+
+    if (!this.model.getTableColumn(timestampColumnName)) {
+      throw new BadDataException(
+        `Invalid timestampColumnName: ${timestampColumnName}`,
+      );
+    }
+
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+    const databaseName: string =
+      this.database!.getDatasourceOptions().database!;
+
+    const statement: Statement = SQL`SELECT serviceId AS serviceId, serviceType AS serviceType, count() AS rowCount, sum(byteSize(*)) AS estimatedBytes FROM ${databaseName}.${this.model.tableName} WHERE projectId = ${{
+      type: TableColumnType.ObjectID,
+      value: data.projectId,
+    }} AND ${timestampColumnName} >= ${{
+      type: TableColumnType.DateTime64,
+      value: data.startDate,
+    }} AND ${timestampColumnName} <= ${{
+      type: TableColumnType.DateTime64,
+      value: data.endDate,
+    }} GROUP BY serviceId, serviceType`;
+
+    statement.append(
+      " SETTINGS max_execution_time = 60, timeout_overflow_mode = 'break'",
+    );
+
+    const dbResult: ResultSet<"JSON"> = await this.executeQuery(statement);
+    const responseJSON: ResponseJSON<JSONObject> =
+      await dbResult.json<JSONObject>();
+    const items: Array<JSONObject> = responseJSON.data ? responseJSON.data : [];
+
+    const results: Array<{
+      serviceId: string;
+      serviceType: string | null;
+      rowCount: number;
+      estimatedBytes: number;
+    }> = [];
+
+    for (const item of items) {
+      const serviceId: string = (item["serviceId"] as string) || "";
+      if (!serviceId) {
+        continue;
+      }
+      const serviceTypeRaw: unknown = item["serviceType"];
+      const serviceType: string | null =
+        typeof serviceTypeRaw === "string" && serviceTypeRaw.trim()
+          ? serviceTypeRaw
+          : null;
+      results.push({
+        serviceId,
+        serviceType,
+        rowCount: Number(item["rowCount"]) || 0,
+        estimatedBytes: Number(item["estimatedBytes"]) || 0,
+      });
+    }
+
+    return results;
+  }
+
   @CaptureSpan()
   public async aggregateBy(
     aggregateBy: AggregateBy<TBaseModel>,