@oneuptime/common 9.3.7 → 9.3.9

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

@@ -0,0 +1,224 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+// Schema + Data migration: Move TelemetryService to Service table
+export class MigrationName1767979448478 implements MigrationInterface {
+  public name = "MigrationName1767979448478";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Step 1: Drop old FK constraints (pointing to TelemetryService)
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP CONSTRAINT IF EXISTS "FK_6470c69cb5f53c5899c0483df5f"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" DROP CONSTRAINT IF EXISTS "FK_91333210492e5d2f334231468a7"`,
+    );
+
+    // Step 2: Drop old indexes
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS "public"."IDX_6470c69cb5f53c5899c0483df5"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS "public"."IDX_91333210492e5d2f334231468a"`,
+    );
+
+    // Step 3: Add retainTelemetryDataForDays column to Service (needed before data migration)
+    await queryRunner.query(
+      `ALTER TABLE "Service" ADD COLUMN IF NOT EXISTS "retainTelemetryDataForDays" integer DEFAULT '15'`,
+    );
+
+    /*
+     * Step 4: Migrate TelemetryService data to Service table (BEFORE renaming columns and adding FK)
+     * Preserve the same _id so existing references remain valid
+     */
+    const telemetryServiceTableExists: Array<{ exists: boolean }> =
+      await queryRunner.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_schema = 'public'
+                AND table_name = 'TelemetryService'
+            )
+        `);
+
+    if (telemetryServiceTableExists[0]?.exists) {
+      await queryRunner.query(`
+                INSERT INTO "Service" (
+                    "_id",
+                    "createdAt",
+                    "updatedAt",
+                    "deletedAt",
+                    "version",
+                    "projectId",
+                    "name",
+                    "slug",
+                    "description",
+                    "createdByUserId",
+                    "deletedByUserId",
+                    "serviceColor",
+                    "retainTelemetryDataForDays"
+                )
+                SELECT
+                    "_id",
+                    "createdAt",
+                    "updatedAt",
+                    "deletedAt",
+                    "version",
+                    "projectId",
+                    "name",
+                    "slug",
+                    "description",
+                    "createdByUserId",
+                    "deletedByUserId",
+                    "serviceColor",
+                    "retainTelemetryDataForDays"
+                FROM "TelemetryService"
+                ON CONFLICT ("_id") DO NOTHING
+            `);
+    }
+
+    // Step 5: Migrate TelemetryServiceLabel to ServiceLabel
+    const telemetryServiceLabelExists: Array<{ exists: boolean }> =
+      await queryRunner.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_schema = 'public'
+                AND table_name = 'TelemetryServiceLabel'
+            )
+        `);
+
+    if (telemetryServiceLabelExists[0]?.exists) {
+      await queryRunner.query(`
+                INSERT INTO "ServiceLabel" ("serviceId", "labelId")
+                SELECT "telemetryServiceId", "labelId"
+                FROM "TelemetryServiceLabel"
+                ON CONFLICT DO NOTHING
+            `);
+    }
+
+    // Step 6: Rename columns (telemetryServiceId -> serviceId)
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" RENAME COLUMN "telemetryServiceId" TO "serviceId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" RENAME COLUMN "telemetryServiceId" TO "serviceId"`,
+    );
+
+    // Step 7: Create MetricTypeService table
+    await queryRunner.query(
+      `CREATE TABLE IF NOT EXISTS "MetricTypeService" ("metricTypeId" uuid NOT NULL, "serviceId" uuid NOT NULL, CONSTRAINT "PK_21b7a84eea5b71922ac5ccc92e9" PRIMARY KEY ("metricTypeId", "serviceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_e6b6e365ad502b487cb63d2891" ON "MetricTypeService" ("metricTypeId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_c67839207ff53f33eb22648b56" ON "MetricTypeService" ("serviceId") `,
+    );
+
+    // Step 8: Migrate MetricTypeTelemetryService to MetricTypeService
+    const metricTypeTelemetryServiceExists: Array<{ exists: boolean }> =
+      await queryRunner.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_schema = 'public'
+                AND table_name = 'MetricTypeTelemetryService'
+            )
+        `);
+
+    if (metricTypeTelemetryServiceExists[0]?.exists) {
+      await queryRunner.query(`
+                INSERT INTO "MetricTypeService" ("metricTypeId", "serviceId")
+                SELECT "metricTypeId", "telemetryServiceId"
+                FROM "MetricTypeTelemetryService"
+                ON CONFLICT DO NOTHING
+            `);
+    }
+
+    // Step 10: Create new indexes
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_08a0cfa9f184257b1e57da4cf5" ON "TelemetryException" ("serviceId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_b9f49cd8318a35757fc843ee90" ON "TelemetryUsageBilling" ("serviceId") `,
+    );
+
+    // Step 11: Add new FK constraints (NOW safe because Service table has the migrated data)
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD CONSTRAINT "FK_08a0cfa9f184257b1e57da4cf50" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" ADD CONSTRAINT "FK_b9f49cd8318a35757fc843ee900" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeService" ADD CONSTRAINT "FK_e6b6e365ad502b487cb63d28913" FOREIGN KEY ("metricTypeId") REFERENCES "MetricType"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeService" ADD CONSTRAINT "FK_c67839207ff53f33eb22648b567" FOREIGN KEY ("serviceId") REFERENCES "Service"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Drop new FK constraints
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeService" DROP CONSTRAINT "FK_c67839207ff53f33eb22648b567"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeService" DROP CONSTRAINT "FK_e6b6e365ad502b487cb63d28913"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" DROP CONSTRAINT "FK_b9f49cd8318a35757fc843ee900"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP CONSTRAINT "FK_08a0cfa9f184257b1e57da4cf50"`,
+    );
+
+    // Drop new indexes
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b9f49cd8318a35757fc843ee90"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_08a0cfa9f184257b1e57da4cf5"`,
+    );
+
+    // Drop retainTelemetryDataForDays column
+    await queryRunner.query(
+      `ALTER TABLE "Service" DROP COLUMN "retainTelemetryDataForDays"`,
+    );
+
+    // Drop MetricTypeService table and indexes
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c67839207ff53f33eb22648b56"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e6b6e365ad502b487cb63d2891"`,
+    );
+    await queryRunner.query(`DROP TABLE "MetricTypeService"`);
+
+    // Rename columns back
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" RENAME COLUMN "serviceId" TO "telemetryServiceId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" RENAME COLUMN "serviceId" TO "telemetryServiceId"`,
+    );
+
+    // Recreate old indexes
+    await queryRunner.query(
+      `CREATE INDEX "IDX_91333210492e5d2f334231468a" ON "TelemetryUsageBilling" ("telemetryServiceId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_6470c69cb5f53c5899c0483df5" ON "TelemetryException" ("telemetryServiceId") `,
+    );
+
+    // Restore old FK constraints (pointing back to TelemetryService)
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryUsageBilling" ADD CONSTRAINT "FK_91333210492e5d2f334231468a7" FOREIGN KEY ("telemetryServiceId") REFERENCES "TelemetryService"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD CONSTRAINT "FK_6470c69cb5f53c5899c0483df5f" FOREIGN KEY ("telemetryServiceId") REFERENCES "TelemetryService"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+
+    /*
+     * Note: We don't delete the migrated data from Service table in down migration
+     * as it could be dangerous if new Service records were created
+     */
+  }
+}

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

@@ -213,6 +213,9 @@ import { AddAIAgentIsDefault1766918848434 } from "./1766918848434-AddAIAgentIsDe
 import { MigrationName1766923324521 } from "./1766923324521-MigrationName";
 import { AddGitHubAppInstallationIdToProject1766958924188 } from "./1766958924188-AddGitHubAppInstallationIdToProject";
 import { MigrationName1767009661768 } from "./1767009661768-MigrationName";
+import { RenameServiceCatalogToService1767966850199 } from "./1767966850199-RenameServiceCatalogToService";
+import { MigrationName1767979055522 } from "./1767979055522-MigrationName";
+import { MigrationName1767979448478 } from "./1767979448478-MigrationName";
 
 export default [
   InitialMigration,
@@ -430,4 +433,7 @@ export default [
   MigrationName1766923324521,
   AddGitHubAppInstallationIdToProject1766958924188,
   MigrationName1767009661768,
+  RenameServiceCatalogToService1767966850199,
+  MigrationName1767979055522,
+  MigrationName1767979448478,
 ];

package/Server/Services/Index.ts

@@ -87,12 +87,11 @@ import ScheduledMaintenancePublicNoteService from "./ScheduledMaintenancePublicN
 import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
 import ScheduledMaintenanceStateService from "./ScheduledMaintenanceStateService";
 import ScheduledMaintenanceStateTimelineService from "./ScheduledMaintenanceStateTimelineService";
-import ServiceCatalogOwnerTeamService from "./ServiceCatalogOwnerTeamService";
-import ServiceCatalogOwnerUserService from "./ServiceCatalogOwnerUserService";
-import ServiceCatalogService from "./ServiceCatalogService";
-import ServiceCatalogMonitorService from "./ServiceCatalogMonitorService";
-import ServiceCatalogTelemetryServiceService from "./ServiceCatalogTelemetryServiceService";
-import ServiceCatalogCodeRepositoryService from "./ServiceCatalogCodeRepositoryService";
+import ServiceOwnerTeamService from "./ServiceOwnerTeamService";
+import ServiceOwnerUserService from "./ServiceOwnerUserService";
+import ServiceService from "./ServiceService";
+import ServiceMonitorService from "./ServiceMonitorService";
+import ServiceCodeRepositoryService from "./ServiceCodeRepositoryService";
 import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
 import SmsLogService from "./SmsLogService";
@@ -123,7 +122,6 @@ import TeamPermissionService from "./TeamPermissionService";
 import TeamComplianceSettingService from "./TeamComplianceSettingService";
 // Team
 import TeamService from "./TeamService";
-import TelemetryServiceService from "./TelemetryServiceService";
 import UsageBillingService from "./TelemetryUsageBillingService";
 import UserCallService from "./UserCallService";
 import UserEmailService from "./UserEmailService";
@@ -142,7 +140,7 @@ import WorkflowLogService from "./WorkflowLogService";
 import WorkflowService from "./WorkflowService";
 import WorkflowVariablesService from "./WorkflowVariableService";
 import AnalyticsBaseModel from "../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
-import ServiceCatalogDependencyService from "./ServiceCatalogDependencyService";
+import ServiceDependencyService from "./ServiceDependencyService";
 import TelemetryExceptionService from "./TelemetryExceptionService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
 import ScheduledMaintenanceTemplateService from "./ScheduledMaintenanceTemplateService";
@@ -315,8 +313,6 @@ const services: Array<BaseService> = [
   MonitorGroupOwnerUserService,
   MonitorGroupOwnerTeamService,
 
-  TelemetryServiceService,
-
   // On Call Duty Policy Schedule
   OnCallDutyPolicyScheduleService,
   OnCallDutyPolicyScheduleLayerUserService,
@@ -326,13 +322,12 @@ const services: Array<BaseService> = [
   UsageBillingService,
   ProjectCallSMSConfigService,
 
-  ServiceCatalogService,
-  ServiceCatalogOwnerTeamService,
-  ServiceCatalogOwnerUserService,
-  ServiceCatalogDependencyService,
-  ServiceCatalogMonitorService,
-  ServiceCatalogTelemetryServiceService,
-  ServiceCatalogCodeRepositoryService,
+  ServiceService,
+  ServiceOwnerTeamService,
+  ServiceOwnerUserService,
+  ServiceDependencyService,
+  ServiceMonitorService,
+  ServiceCodeRepositoryService,
 
   TelemetryExceptionService,
 

package/Server/Services/OpenTelemetryIngestService.ts

@@ -4,8 +4,8 @@ import ObjectID from "../../Types/ObjectID";
 import Metric, {
   AggregationTemporality,
 } from "../../Models/AnalyticsModels/Metric";
-import TelemetryService from "../../Models/DatabaseModels/TelemetryService";
-import TelemetryServiceService from "../../Server/Services/TelemetryServiceService";
+import Service from "../../Models/DatabaseModels/Service";
+import ServiceService from "../../Server/Services/ServiceService";
 import { DEFAULT_RETENTION_IN_DAYS } from "../../Models/DatabaseModels/TelemetryUsageBilling";
 import TelemetryUtil from "../../Server/Utils/Telemetry/Telemetry";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -30,37 +30,35 @@ export default class OTelIngestService {
     serviceId: ObjectID;
     dataRententionInDays: number;
   }> {
-    const service: TelemetryService | null =
-      await TelemetryServiceService.findOneBy({
-        query: {
-          projectId: data.projectId,
-          name: data.serviceName,
-        },
-        select: {
-          _id: true,
-          retainTelemetryDataForDays: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
+    const service: Service | null = await ServiceService.findOneBy({
+      query: {
+        projectId: data.projectId,
+        name: data.serviceName,
+      },
+      select: {
+        _id: true,
+        retainTelemetryDataForDays: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
 
     if (!service) {
       // create service
 
-      const newService: TelemetryService = new TelemetryService();
+      const newService: Service = new Service();
       newService.projectId = data.projectId;
       newService.name = data.serviceName;
       newService.description = data.serviceName;
       newService.retainTelemetryDataForDays = DEFAULT_RETENTION_IN_DAYS;
 
-      const createdService: TelemetryService =
-        await TelemetryServiceService.create({
-          data: newService,
-          props: {
-            isRoot: true,
-          },
-        });
+      const createdService: Service = await ServiceService.create({
+        data: newService,
+        props: {
+          isRoot: true,
+        },
+      });
 
       return {
         serviceId: createdService.id!,
@@ -80,8 +78,8 @@ export default class OTelIngestService {
     datapoint: JSONObject;
     aggregationTemporality: OtelAggregationTemporality;
     isMonotonic: boolean | undefined;
-    telemetryServiceId: ObjectID;
-    telemetryServiceName: string;
+    serviceId: ObjectID;
+    serviceName: string;
   }): Metric {
     const { dbMetric, datapoint, aggregationTemporality, isMonotonic } = data;
 
@@ -164,8 +162,8 @@ export default class OTelIngestService {
 
       newDbMetric.attributes = {
         ...TelemetryUtil.getAttributesForServiceIdAndServiceName({
-          serviceId: data.telemetryServiceId,
-          serviceName: data.telemetryServiceName,
+          serviceId: data.serviceId,
+          serviceName: data.serviceName,
         }),
         ...TelemetryUtil.getAttributes({
           items: (datapoint["attributes"] as JSONArray) || [],

package/Server/Services/{ServiceCatalogCodeRepositoryService.ts → ServiceCodeRepositoryService.ts}

@@ -2,7 +2,7 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/ServiceCatalogCodeRepository";
+import Model from "../../Models/DatabaseModels/ServiceCodeRepository";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -15,23 +15,23 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
-    if (!createBy.data.serviceCatalogId && !createBy.data.serviceCatalog) {
-      throw new BadDataException("serviceCatalog is required");
+    if (!createBy.data.serviceId && !createBy.data.service) {
+      throw new BadDataException("service is required");
     }
 
     if (!createBy.data.codeRepository && !createBy.data.codeRepositoryId) {
       throw new BadDataException("codeRepository is required");
     }
 
-    const serviceCatalogId: string | ObjectID | undefined =
-      createBy.data.serviceCatalogId || createBy.data.serviceCatalog?._id;
+    const serviceId: string | ObjectID | undefined =
+      createBy.data.serviceId || createBy.data.service?._id;
     const codeRepositoryId: string | ObjectID | undefined =
       createBy.data.codeRepositoryId || createBy.data.codeRepository?._id;
 
-    // check if this code repository is already added to the service catalog for this service.
+    // check if this code repository is already added to the service for this service.
     const existingCodeRepository: Model | null = await this.findOneBy({
       query: {
-        serviceCatalogId: serviceCatalogId as ObjectID,
+        serviceId: serviceId as ObjectID,
         codeRepositoryId: codeRepositoryId as ObjectID,
       },
       props: {

package/Server/Services/ServiceDependencyService.ts

@@ -0,0 +1,48 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ServiceDependency";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    // select a random color.
+
+    if (!createBy.data.serviceId && !createBy.data.service) {
+      throw new BadDataException("service is required");
+    }
+
+    if (
+      !createBy.data.dependencyServiceId &&
+      !createBy.data.dependencyService
+    ) {
+      throw new BadDataException("dependencyService is required");
+    }
+
+    // serviceId and dependencyServiceId should not be the same
+    const serviceId: string | ObjectID | undefined =
+      createBy.data.serviceId || createBy.data.service?._id;
+    const dependencyServiceId: string | ObjectID | undefined =
+      createBy.data.dependencyServiceId || createBy.data.dependencyService?._id;
+
+    if (serviceId?.toString() === dependencyServiceId?.toString()) {
+      throw new BadDataException("Service cannot depend on itself.");
+    }
+
+    return {
+      carryForward: null,
+      createBy: createBy,
+    };
+  }
+}
+
+export default new Service();

package/Server/Services/{ServiceCatalogMonitorService.ts → ServiceMonitorService.ts}

@@ -2,7 +2,7 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/ServiceCatalogMonitor";
+import Model from "../../Models/DatabaseModels/ServiceMonitor";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -17,25 +17,25 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnCreate<Model>> {
     // select a random color.
 
-    if (!createBy.data.serviceCatalogId && !createBy.data.serviceCatalog) {
-      throw new BadDataException("serviceCatalog is required");
+    if (!createBy.data.serviceId && !createBy.data.service) {
+      throw new BadDataException("service is required");
     }
 
     if (!createBy.data.monitor && !createBy.data.monitorId) {
       throw new BadDataException("monitor is required");
     }
 
-    // serviceCatalogId and dependencyServiceCatalogId should not be the same
-    const serviceCatalogId: string | ObjectID | undefined =
-      createBy.data.serviceCatalogId || createBy.data.serviceCatalog?._id;
+    // serviceId and dependencyServiceId should not be the same
+    const serviceId: string | ObjectID | undefined =
+      createBy.data.serviceId || createBy.data.service?._id;
     const monitorId: string | ObjectID | undefined =
       createBy.data.monitorId || createBy.data.monitor?._id;
 
-    // check if this monitor is already added to the service catalog for this service.
+    // check if this monitor is already added to the service for this service.
 
     const existingMonitor: Model | null = await this.findOneBy({
       query: {
-        serviceCatalogId: serviceCatalogId as ObjectID,
+        serviceId: serviceId as ObjectID,
         monitorId: monitorId as ObjectID,
       },
       props: {

package/Server/Services/{ServiceCatalogOwnerTeamService.ts → ServiceOwnerTeamService.ts}

@@ -1,5 +1,5 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/ServiceCatalogOwnerTeam";
+import Model from "../../Models/DatabaseModels/ServiceOwnerTeam";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {

package/Server/Services/{ServiceCatalogOwnerUserService.ts → ServiceOwnerUserService.ts}

@@ -1,5 +1,5 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/ServiceCatalogOwnerUser";
+import Model from "../../Models/DatabaseModels/ServiceOwnerUser";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {

package/Server/Services/{TelemetryServiceService.ts → ServiceService.ts}

@@ -5,7 +5,7 @@ import ArrayUtil from "../../Utils/Array";
 import { BrightColors } from "../../Types/BrandColors";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
-import Model from "../../Models/DatabaseModels/TelemetryService";
+import Model from "../../Models/DatabaseModels/Service";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
@@ -17,8 +17,6 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
-    createBy.data.telemetryServiceToken = ObjectID.generate();
-
     // select a random color.
     createBy.data.serviceColor = ArrayUtil.selectItemByRandom(BrightColors);
 
@@ -30,10 +28,10 @@ export class Service extends DatabaseService<Model> {
 
   @CaptureSpan()
   public async getTelemetryDataRetentionInDays(
-    telemetryServiceId: ObjectID,
+    serviceId: ObjectID,
   ): Promise<number> {
-    const project: Model | null = await this.findOneById({
-      id: telemetryServiceId,
+    const service: Model | null = await this.findOneById({
+      id: serviceId,
       select: {
         retainTelemetryDataForDays: true,
       },
@@ -42,11 +40,11 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
-    if (!project) {
-      throw new BadDataException("Project not found");
+    if (!service) {
+      throw new BadDataException("Service not found");
     }
 
-    return project.retainTelemetryDataForDays || 15; // default is 15 days.
+    return service.retainTelemetryDataForDays || 15; // default is 15 days.
   }
 }
 

package/Server/Services/TelemetryExceptionService.ts

@@ -37,7 +37,7 @@ export class Service extends DatabaseService<Model> {
         projectId: true,
         message: true,
         stackTrace: true,
-        telemetryServiceId: true,
+        serviceId: true,
         exceptionType: true,
       },
       props,
@@ -160,9 +160,8 @@ export class Service extends DatabaseService<Model> {
       metadata.errorMessage = telemetryException.message;
     }
 
-    if (telemetryException.telemetryServiceId) {
-      metadata.telemetryServiceId =
-        telemetryException.telemetryServiceId.toString();
+    if (telemetryException.serviceId) {
+      metadata.serviceId = telemetryException.serviceId.toString();
     }
 
     return metadata;