@oneuptime/common 9.3.8 → 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

@@ -214,6 +214,8 @@ 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,
@@ -432,4 +434,6 @@ export default [
   AddGitHubAppInstallationIdToProject1766958924188,
   MigrationName1767009661768,
   RenameServiceCatalogToService1767966850199,
+  MigrationName1767979055522,
+  MigrationName1767979448478,
 ];

package/Server/Services/Index.ts

@@ -91,7 +91,6 @@ import ServiceOwnerTeamService from "./ServiceOwnerTeamService";
 import ServiceOwnerUserService from "./ServiceOwnerUserService";
 import ServiceService from "./ServiceService";
 import ServiceMonitorService from "./ServiceMonitorService";
-import ServiceTelemetryServiceService from "./ServiceTelemetryServiceService";
 import ServiceCodeRepositoryService from "./ServiceCodeRepositoryService";
 import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
@@ -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";
@@ -315,8 +313,6 @@ const services: Array<BaseService> = [
   MonitorGroupOwnerUserService,
   MonitorGroupOwnerTeamService,
 
-  TelemetryServiceService,
-
   // On Call Duty Policy Schedule
   OnCallDutyPolicyScheduleService,
   OnCallDutyPolicyScheduleLayerUserService,
@@ -331,7 +327,6 @@ const services: Array<BaseService> = [
   ServiceOwnerUserService,
   ServiceDependencyService,
   ServiceMonitorService,
-  ServiceTelemetryServiceService,
   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/ServiceService.ts

@@ -3,6 +3,8 @@ import { OnCreate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 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/Service";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -23,6 +25,27 @@ export class Service extends DatabaseService<Model> {
       createBy: createBy,
     };
   }
+
+  @CaptureSpan()
+  public async getTelemetryDataRetentionInDays(
+    serviceId: ObjectID,
+  ): Promise<number> {
+    const service: Model | null = await this.findOneById({
+      id: serviceId,
+      select: {
+        retainTelemetryDataForDays: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!service) {
+      throw new BadDataException("Service not found");
+    }
+
+    return service.retainTelemetryDataForDays || 15; // default is 15 days.
+  }
 }
 
 export default new Service();

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;

package/Server/Services/TelemetryUsageBillingService.ts

@@ -11,7 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import Model, {
   DEFAULT_RETENTION_IN_DAYS,
 } from "../../Models/DatabaseModels/TelemetryUsageBilling";
-import TelemetryServiceService from "./TelemetryServiceService";
+import ServiceService from "./ServiceService";
 import SpanService from "./SpanService";
 import LogService from "./LogService";
 import MetricService from "./MetricService";
@@ -20,7 +20,7 @@ import AnalyticsQueryHelper from "../Types/AnalyticsDatabase/QueryHelper";
 import DiskSize from "../../Types/DiskSize";
 import logger from "../Utils/Logger";
 import PositiveNumber from "../../Types/PositiveNumber";
-import TelemetryServiceModel from "../../Models/DatabaseModels/TelemetryService";
+import ServiceModel from "../../Models/DatabaseModels/Service";
 import {
   AverageSpanRowSizeInBytes,
   AverageLogRowSizeInBytes,
@@ -97,28 +97,27 @@ export class Service extends DatabaseService<Model> {
     const startOfDay: Date = OneUptimeDate.getStartOfDay(usageDate);
     const endOfDay: Date = OneUptimeDate.getEndOfDay(usageDate);
 
-    const telemetryServices: Array<TelemetryServiceModel> =
-      await TelemetryServiceService.findBy({
-        query: {
-          projectId: data.projectId,
-        },
-        select: {
-          _id: true,
-          retainTelemetryDataForDays: true,
-        },
-        skip: 0,
-        limit: LIMIT_MAX,
-        props: {
-          isRoot: true,
-        },
-      });
+    const services: Array<ServiceModel> = await ServiceService.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        _id: true,
+        retainTelemetryDataForDays: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
 
-    if (!telemetryServices || telemetryServices.length === 0) {
+    if (!services || services.length === 0) {
       return;
     }
 
-    for (const telemetryService of telemetryServices) {
-      if (!telemetryService?.id) {
+    for (const service of services) {
+      if (!service?.id) {
         continue;
       }
 
@@ -126,7 +125,7 @@ export class Service extends DatabaseService<Model> {
         query: {
           projectId: data.projectId,
           productType: data.productType,
-          telemetryServiceId: telemetryService.id,
+          serviceId: service.id,
           day: usageDayString,
         },
         select: {
@@ -148,7 +147,7 @@ export class Service extends DatabaseService<Model> {
           const spanCount: PositiveNumber = await SpanService.countBy({
             query: {
               projectId: data.projectId,
-              serviceId: telemetryService.id,
+              serviceId: service.id,
               startTime: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
             },
             skip: 0,
@@ -162,7 +161,7 @@ export class Service extends DatabaseService<Model> {
             await ExceptionInstanceService.countBy({
               query: {
                 projectId: data.projectId,
-                serviceId: telemetryService.id,
+                serviceId: service.id,
                 time: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
               },
               skip: 0,
@@ -186,7 +185,7 @@ export class Service extends DatabaseService<Model> {
           const count: PositiveNumber = await LogService.countBy({
             query: {
               projectId: data.projectId,
-              serviceId: telemetryService.id,
+              serviceId: service.id,
               time: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
             },
             skip: 0,
@@ -207,7 +206,7 @@ export class Service extends DatabaseService<Model> {
           const count: PositiveNumber = await MetricService.countBy({
             query: {
               projectId: data.projectId,
-              serviceId: telemetryService.id,
+              serviceId: service.id,
               time: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
             },
             skip: 0,
@@ -227,7 +226,7 @@ export class Service extends DatabaseService<Model> {
         }
       } catch (error) {
         logger.error(
-          `Failed to compute telemetry usage for service ${telemetryService.id?.toString()}:`,
+          `Failed to compute telemetry usage for service ${service.id?.toString()}:`,
         );
         logger.error(error as Error);
         continue;
@@ -244,13 +243,12 @@ export class Service extends DatabaseService<Model> {
       }
 
       const dataRetentionInDays: number =
-        telemetryService.retainTelemetryDataForDays ||
-        DEFAULT_RETENTION_IN_DAYS;
+        service.retainTelemetryDataForDays || DEFAULT_RETENTION_IN_DAYS;
 
       await this.updateUsageBilling({
         projectId: data.projectId,
         productType: data.productType,
-        telemetryServiceId: telemetryService.id,
+        serviceId: service.id,
         dataIngestedInGB: estimatedGigabytes,
         retentionInDays: dataRetentionInDays,
         usageDate: usageDate,
@@ -262,7 +260,7 @@ export class Service extends DatabaseService<Model> {
   public async updateUsageBilling(data: {
     projectId: ObjectID;
     productType: ProductType;
-    telemetryServiceId: ObjectID;
+    serviceId: ObjectID;
     dataIngestedInGB: number;
     retentionInDays: number;
     usageDate?: Date;
@@ -298,7 +296,7 @@ export class Service extends DatabaseService<Model> {
       query: {
         projectId: data.projectId,
         productType: data.productType,
-        telemetryServiceId: data.telemetryServiceId,
+        serviceId: data.serviceId,
         isReportedToBillingProvider: false,
         day: usageDayString,
       },
@@ -347,7 +345,7 @@ export class Service extends DatabaseService<Model> {
       usageBilling.projectId = data.projectId;
       usageBilling.productType = data.productType;
       usageBilling.dataIngestedInGB = new Decimal(data.dataIngestedInGB);
-      usageBilling.telemetryServiceId = data.telemetryServiceId;
+      usageBilling.serviceId = data.serviceId;
       usageBilling.retainTelemetryDataForDays = data.retentionInDays;
       usageBilling.isReportedToBillingProvider = false;
       usageBilling.createdAt = usageDate;