@oneuptime/common 10.5.8 → 10.5.17

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

@@ -360,6 +360,11 @@ import { AddLabelGroupByToGroupingRules1779971548393 } from "./1779971548393-Add
 import { AddTransportTypeToProjectSmtpConfig1779975064262 } from "./1779975064262-AddTransportTypeToProjectSmtpConfig";
 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,
@@ -724,4 +729,9 @@ export default [
   AddTransportTypeToProjectSmtpConfig1779975064262,
   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>,

package/Server/Services/DatabaseService.ts

@@ -54,6 +54,7 @@ import HashedString from "../../Types/HashedString";
 import { JSONObject, JSONValue } from "../../Types/JSON";
 import JSONFunctions from "../../Types/JSONFunctions";
 import ObjectID from "../../Types/ObjectID";
+import TelemetryContext from "../Utils/Telemetry/TelemetryContext";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Text from "../../Types/Text";
 import Typeof from "../../Types/Typeof";
@@ -681,6 +682,69 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     }
   }
 
+  /**
+   * Derive the telemetry attribute key for this model's primary id, e.g.
+   * `Incident` -> `incidentId`, `Monitor` -> `monitorId`. Matches the keys in
+   * TelemetryContextAttributes so dashboards/queries stay consistent.
+   */
+  private getTelemetryEntityIdKey(): string {
+    const name: string = this.modelName || "entity";
+    return name.charAt(0).toLowerCase() + name.slice(1) + "Id";
+  }
+
+  /**
+   * Seed the ambient telemetry context with the project (tenant) of an
+   * operation so worker/cron/service spans and logs — which run outside the
+   * HTTP request scope — still carry projectId. Best-effort and safe to call
+   * anywhere.
+   */
+  protected setTelemetryContextFromProps(
+    props: DatabaseCommonInteractionProps | undefined,
+  ): void {
+    try {
+      if (props?.tenantId) {
+        TelemetryContext.setAttributes({
+          projectId: props.tenantId.toString(),
+        });
+      }
+    } catch {
+      // Telemetry must never break a database operation.
+    }
+  }
+
+  /**
+   * Seed the ambient telemetry context from a concrete model instance: the
+   * project (tenant) and the entity's own id (e.g. incidentId, monitorId).
+   * Used on create, where a new entity id is minted. Best-effort and safe.
+   */
+  protected setTelemetryContextFromItem(item: TBaseModel | undefined): void {
+    try {
+      if (!item) {
+        return;
+      }
+
+      const attributes: { [key: string]: string } = {};
+
+      const tenantColumn: string | null = this.model.getTenantColumn();
+      if (tenantColumn) {
+        const tenantValue: unknown = item.getColumnValue(tenantColumn);
+        if (tenantValue) {
+          attributes["projectId"] = String(tenantValue);
+        }
+      }
+
+      if (item.id) {
+        attributes[this.getTelemetryEntityIdKey()] = item.id.toString();
+      }
+
+      if (Object.keys(attributes).length > 0) {
+        TelemetryContext.setAttributes(attributes);
+      }
+    } catch {
+      // Telemetry must never break a database operation.
+    }
+  }
+
   @CaptureSpan()
   public async create(createBy: CreateBy<TBaseModel>): Promise<TBaseModel> {
     const onCreate: OnCreate<TBaseModel> = createBy.props.ignoreHooks
@@ -742,6 +806,9 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     try {
       createBy.data = await this.getRepository().save(createBy.data);
 
+      // Seed telemetry context with projectId + <model>Id for this create.
+      this.setTelemetryContextFromItem(createBy.data);
+
       if (!createBy.props.ignoreHooks) {
         createBy.data = await this.onCreateSuccess(
           {
@@ -1216,6 +1283,8 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
 
   private async _deleteBy(deleteBy: DeleteBy<TBaseModel>): Promise<number> {
     try {
+      this.setTelemetryContextFromProps(deleteBy.props);
+
       if (this.doNotAllowDelete && !deleteBy.props.isRoot) {
         throw new BadDataException("Delete not allowed");
       }
@@ -1444,6 +1513,8 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     withDeleted?: boolean | undefined,
   ): Promise<Array<TBaseModel>> {
     try {
+      this.setTelemetryContextFromProps(findBy.props);
+
       let automaticallyAddedCreatedAtInSelect: boolean = false;
 
       if (!findBy.sort || Object.keys(findBy.sort).length === 0) {
@@ -1638,6 +1709,8 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
 
   private async _updateBy(updateBy: UpdateBy<TBaseModel>): Promise<number> {
     try {
+      this.setTelemetryContextFromProps(updateBy.props);
+
       const onUpdate: OnUpdate<TBaseModel> = updateBy.props.ignoreHooks
         ? { updateBy, carryForward: [] }
         : await this.onBeforeUpdate(updateBy);

package/Server/Services/TelemetryExceptionService.ts

@@ -1,10 +1,9 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/TelemetryException";
-import TelemetryServiceModel from "../../Models/DatabaseModels/Service";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
 import AIAgentTaskTelemetryException from "../../Models/DatabaseModels/AIAgentTaskTelemetryException";
 import ObjectID from "../../Types/ObjectID";
-import PositiveNumber from "../../Types/PositiveNumber";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import BadDataException from "../../Types/Exception/BadDataException";
 import AIAgentTaskType from "../../Types/AI/AIAgentTaskType";
@@ -13,7 +12,6 @@ import { FixExceptionTaskMetadata } from "../../Types/AI/AIAgentTaskMetadata";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import AIAgentTaskService from "./AIAgentTaskService";
 import AIAgentTaskTelemetryExceptionService from "./AIAgentTaskTelemetryExceptionService";
-import ServiceService from "./ServiceService";
 import QueryHelper from "../Types/Database/QueryHelper";
 import ModelPermission from "../Types/Database/Permissions/Index";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -24,7 +22,13 @@ export interface CreateAIAgentTaskForExceptionParams {
 }
 
 export interface DashboardServiceSummary {
-  service: TelemetryServiceModel;
+  /*
+   * Polymorphic: a real Service, a Host/DockerHost/KubernetesCluster id, or
+   * the projectId for unattributed telemetry. The client resolves the
+   * display name per serviceType.
+   */
+  serviceId: string;
+  serviceType: ServiceType | null;
   unresolvedCount: number;
   totalOccurrences: number;
 }
@@ -182,11 +186,9 @@ export class Service extends DatabaseService<Model> {
       lastSeenAt: true,
       firstSeenAt: true,
       environment: true,
-      service: {
-        _id: true,
-        name: true,
-        serviceColor: true,
-      },
+      // serviceId is polymorphic; the client resolves it per serviceType.
+      serviceId: true,
+      serviceType: true,
     };
 
     const [
@@ -284,6 +286,7 @@ export class Service extends DatabaseService<Model> {
 
     interface AggregateRow {
       serviceId: string | null;
+      serviceType: string | null;
       unresolvedCount: string;
       totalOccurrences: string | null;
     }
@@ -292,6 +295,7 @@ export class Service extends DatabaseService<Model> {
       "TelemetryException",
     )
       .select(`"TelemetryException"."serviceId"`, "serviceId")
+      .addSelect(`"TelemetryException"."serviceType"`, "serviceType")
       .addSelect(`COUNT(*)`, "unresolvedCount")
       .addSelect(
         `COALESCE(SUM("TelemetryException"."occuranceCount"), 0)`,
@@ -305,6 +309,7 @@ export class Service extends DatabaseService<Model> {
       .andWhere(`"TelemetryException"."deletedAt" IS NULL`)
       .andWhere(`"TelemetryException"."serviceId" IS NOT NULL`)
       .groupBy(`"TelemetryException"."serviceId"`)
+      .addGroupBy(`"TelemetryException"."serviceType"`)
       .orderBy(`"unresolvedCount"`, "DESC")
       .getRawMany()) as Array<AggregateRow>;
 
@@ -312,52 +317,22 @@ export class Service extends DatabaseService<Model> {
       return [];
     }
 
-    const serviceIds: Array<string> = [];
-    for (const row of rows) {
-      if (row.serviceId) {
-        serviceIds.push(row.serviceId);
-      }
-    }
-
-    if (serviceIds.length === 0) {
-      return [];
-    }
-
-    const services: Array<TelemetryServiceModel> = await ServiceService.findBy({
-      query: {
-        projectId,
-        _id: QueryHelper.any(serviceIds),
-      },
-      select: {
-        _id: true,
-        name: true,
-        serviceColor: true,
-      },
-      limit: new PositiveNumber(serviceIds.length),
-      skip: new PositiveNumber(0),
-      props,
-    });
-
-    const serviceById: Map<string, TelemetryServiceModel> = new Map();
-    for (const service of services) {
-      if (service._id) {
-        serviceById.set(service._id, service);
-      }
-    }
-
+    /*
+     * serviceId is polymorphic — do NOT resolve it to a Service here. The
+     * old code looked each serviceId up in the Service table and dropped
+     * any that didn't match, which silently excluded Host / DockerHost /
+     * KubernetesCluster and unattributed (Unknown) telemetry. Return the
+     * raw (serviceId, serviceType) + counts; the client resolves the
+     * display name per serviceType.
+     */
     const summaries: Array<DashboardServiceSummary> = [];
     for (const row of rows) {
       if (!row.serviceId) {
         continue;
       }
-      const service: TelemetryServiceModel | undefined = serviceById.get(
-        row.serviceId,
-      );
-      if (!service) {
-        continue;
-      }
       summaries.push({
-        service,
+        serviceId: row.serviceId,
+        serviceType: (row.serviceType as ServiceType | null) ?? null,
         unresolvedCount: parseInt(row.unresolvedCount, 10) || 0,
         totalOccurrences: parseInt(row.totalOccurrences || "0", 10) || 0,
       });