@oneuptime/common 7.0.3976 → 7.0.3985

package/Models/DatabaseModels/Index.ts

@@ -168,6 +168,7 @@ import WorkspaceNotificationRule from "./WorkspaceNotificationRule";
 import ProjectUser from "./ProjectUser";
 import OnCallDutyPolicyUserOverride from "./OnCallDutyPolicyUserOverride";
 import MonitorFeed from "./MonitorFeed";
+import MetricType from "./MetricType";
 
 const AllModelTypes: Array<{
   new (): BaseModel;
@@ -361,6 +362,8 @@ const AllModelTypes: Array<{
   ProjectUser,
 
   MonitorFeed,
+
+  MetricType,
 ];
 
 const modelTypeMap: { [key: string]: { new (): BaseModel } } = {};

package/Models/DatabaseModels/Label.ts

@@ -169,6 +169,7 @@ export default class Label extends AccessControlModel {
     length: ColumnLength.ShortText,
   })
   @UniqueColumnBy("projectId")
+  @Index()
   public override name?: string = undefined;
 
   @ColumnAccessControl({

package/Models/DatabaseModels/MetricType.ts

@@ -0,0 +1,339 @@
+import Project from "./Project";
+import User from "./User";
+import Route from "../../Types/API/Route";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import EnableWorkflow from "../../Types/Database/EnableWorkflow";
+import SlugifyColumn from "../../Types/Database/SlugifyColumn";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import UniqueColumnBy from "../../Types/Database/UniqueColumnBy";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import {
+  Column,
+  Entity,
+  Index,
+  JoinColumn,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+} from "typeorm";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import TelemetryService from "./TelemetryService";
+
+@EnableDocumentation()
+@TenantColumn("projectId")
+@TableAccessControl({
+  create: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.CreateTelemetryServiceMetrics,
+  ],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadTelemetryServiceMetrics,
+  ],
+  delete: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.DeleteTelemetryServiceMetrics,
+  ],
+  update: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.EditTelemetryServiceMetrics,
+  ],
+})
+@EnableWorkflow({
+  create: true,
+  delete: true,
+  update: true,
+  read: true,
+})
+@CrudApiEndpoint(new Route("/metric-type"))
+@SlugifyColumn("name", "slug")
+@TableMetadata({
+  tableName: "MetricType",
+  singularName: "Metric Type",
+  pluralName: "Metric Types",
+  icon: IconProp.Graph,
+  tableDescription: "List of all the metrics ingested with OpenTelemetry",
+})
+@Entity({
+  name: "MetricType",
+})
+export default class MetricType extends BaseModel {
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryServiceMetrics,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectIncident,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectIncident,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectIncident,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: TelemetryService,
+    title: "Telemetry Services",
+    description: "List of services this metric is related to",
+  })
+  @ManyToMany(
+    () => {
+      return TelemetryService;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "MetricTypeTelemetryService",
+    inverseJoinColumn: {
+      name: "telemetryServiceId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "metricTypeId",
+      referencedColumnName: "_id",
+    },
+  })
+  public telemetryServices?: Array<TelemetryService> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryServiceMetrics,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryServiceMetrics,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryServiceMetrics,
+    ],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Name",
+    description: "Any friendly name of this object",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  @UniqueColumnBy("projectId")
+  @Index()
+  public name?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryServiceMetrics,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryServiceMetrics,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryServiceMetrics,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+}

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

@@ -0,0 +1,67 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1743518485566 implements MigrationInterface {
+  public name = "MigrationName1743518485566";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "MetricType" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "name" character varying(100) NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_3b19440ac8f314d9c775e026af5" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d25bfc3fab2ebac8e977d88593" ON "MetricType" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "MetricTypeTelemetryService" ("metricTypeId" uuid NOT NULL, "telemetryServiceId" uuid NOT NULL, CONSTRAINT "PK_ff3bdfa86c187345b15bf2d94e5" PRIMARY KEY ("metricTypeId", "telemetryServiceId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2e26ea92e9cb5693040fd0a65b" ON "MetricTypeTelemetryService" ("metricTypeId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_f5ca58781b68c634e61ce25868" ON "MetricTypeTelemetryService" ("telemetryServiceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" ADD CONSTRAINT "FK_d25bfc3fab2ebac8e977d88593a" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" ADD CONSTRAINT "FK_0662070948eed6110c5e108e77f" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" ADD CONSTRAINT "FK_154d3b5c6f725d30753ef209666" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeTelemetryService" ADD CONSTRAINT "FK_2e26ea92e9cb5693040fd0a65bb" FOREIGN KEY ("metricTypeId") REFERENCES "MetricType"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeTelemetryService" ADD CONSTRAINT "FK_f5ca58781b68c634e61ce25868b" FOREIGN KEY ("telemetryServiceId") REFERENCES "TelemetryService"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeTelemetryService" DROP CONSTRAINT "FK_f5ca58781b68c634e61ce25868b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricTypeTelemetryService" DROP CONSTRAINT "FK_2e26ea92e9cb5693040fd0a65bb"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" DROP CONSTRAINT "FK_154d3b5c6f725d30753ef209666"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" DROP CONSTRAINT "FK_0662070948eed6110c5e108e77f"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" DROP CONSTRAINT "FK_d25bfc3fab2ebac8e977d88593a"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_f5ca58781b68c634e61ce25868"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_2e26ea92e9cb5693040fd0a65b"`,
+    );
+    await queryRunner.query(`DROP TABLE "MetricTypeTelemetryService"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d25bfc3fab2ebac8e977d88593"`,
+    );
+    await queryRunner.query(`DROP TABLE "MetricType"`);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1743521461137 implements MigrationInterface {
+  public name = "MigrationName1743521461137";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b2dd2b4597d3514ee4209ccd69" ON "Label" ("name") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2dfba2253270684804431fd3c8" ON "MetricType" ("name") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    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}}}'`,
+    );
+  }
+}

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

@@ -123,6 +123,8 @@ import { MigrationName1742305668133 } from "./1742305668133-MigrationName";
 import { MigrationName1743005293206 } from "./1743005293206-MigrationName";
 import { MigrationName1743006662678 } from "./1743006662678-MigrationName";
 import { MigrationName1743186793413 } from "./1743186793413-MigrationName";
+import { MigrationName1743518485566 } from "./1743518485566-MigrationName";
+import { MigrationName1743521461137 } from "./1743521461137-MigrationName";
 
 export default [
   InitialMigration,
@@ -250,4 +252,6 @@ export default [
   MigrationName1743005293206,
   MigrationName1743006662678,
   MigrationName1743186793413,
+  MigrationName1743518485566,
+  MigrationName1743521461137,
 ];

package/Server/Services/MetricTypeService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/MetricType";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/MonitorStatusTimelineService.ts

@@ -14,7 +14,6 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
-import { IsBillingEnabled } from "../EnvironmentConfig";
 import MonitorFeedService from "./MonitorFeedService";
 import { MonitorFeedEventType } from "../../Models/DatabaseModels/MonitorFeed";
 import MonitorStatus from "../../Models/DatabaseModels/MonitorStatus";
@@ -23,9 +22,6 @@ import MonitorStatusService from "./MonitorStatusService";
 export class Service extends DatabaseService<MonitorStatusTimeline> {
   public constructor() {
     super(MonitorStatusTimeline);
-    if (IsBillingEnabled) {
-      this.hardDeleteItemsOlderThanInDays("startsAt", 120);
-    }
   }
 
   @CaptureSpan()

package/Server/Utils/Monitor/MonitorResource.ts

@@ -963,6 +963,26 @@ export default class MonitorResourceUtil {
       },
     });
 
+    // Metric name to serviceId map
+    // example: "cpu.usage" -> [serviceId1, serviceId2]
+    // since these are monitor metrics. They dont belong to any service so we can keep the array empty.
+    const metricNameServiceNameMap: Dictionary<Array<ObjectID>> = {};
+
+    for (const metric of itemsToSave) {
+      const metricName: string = metric.name!;
+      if (!metricNameServiceNameMap[metricName]) {
+        metricNameServiceNameMap[metricName] = [];
+      }
+    }
+
+    // index metrics
+    TelemetryUtil.indexMetricNameServiceNameMap({
+      projectId: data.projectId,
+      metricNameServiceNameMap: metricNameServiceNameMap,
+    }).catch((err: Error) => {
+      logger.error(err);
+    });
+
     // index attributes.
     TelemetryUtil.indexAttributes({
       attributes: [

package/Server/Utils/Telemetry/Telemetry.ts

@@ -6,10 +6,104 @@ import GlobalCache from "../../Infrastructure/GlobalCache";
 import TelemetryAttributeService from "../../Services/TelemetryAttributeService";
 import CaptureSpan from "./CaptureSpan";
 import logger from "../Logger";
+import MetricType from "../../../Models/DatabaseModels/MetricType";
+import MetricTypeService from "../../Services/MetricTypeService";
+import TelemetryService from "../../../Models/DatabaseModels/TelemetryService";
 
 export type AttributeType = string | number | boolean | null;
 
 export default class TelemetryUtil {
+  @CaptureSpan()
+  public static async indexMetricNameServiceNameMap(data: {
+    projectId: ObjectID;
+    metricNameServiceNameMap: Dictionary<Array<ObjectID>>;
+  }): Promise<void> {
+    for (const metricName of Object.keys(data.metricNameServiceNameMap)) {
+      // fetch metric
+      const metricType: MetricType | null = await MetricTypeService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          name: metricName,
+        },
+        select: {
+          telemetryServices: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (metricType) {
+        if (!metricType.telemetryServices) {
+          metricType.telemetryServices = [];
+        }
+
+        const telemetryServiceIds: Array<ObjectID> =
+          metricType.telemetryServices!.map((service: TelemetryService) => {
+            return service.id!;
+          });
+
+        // check if telemetry services are same as the ones in the map
+        const telemetryServicesInMap: Array<ObjectID> =
+          data.metricNameServiceNameMap[metricName] || [];
+
+        let isSame: boolean = true;
+
+        for (const telemetryServiceId of telemetryServicesInMap) {
+          if (
+            telemetryServiceIds.filter((serviceId: ObjectID) => {
+              return serviceId.toString() === telemetryServiceId.toString();
+            }).length === 0
+          ) {
+            isSame = false;
+            // add the service id to the list
+            const telemetryService: TelemetryService = new TelemetryService();
+            telemetryService.id = telemetryServiceId;
+            metricType.telemetryServices!.push(telemetryService);
+          }
+        }
+
+        // if its not the same then update the metric type
+
+        if (!isSame) {
+          // update metric type
+          await MetricTypeService.updateOneById({
+            id: metricType.id!,
+            data: {
+              telemetryServices: metricType.telemetryServices || [],
+            },
+            props: {
+              isRoot: true,
+            },
+          } as any);
+        }
+      } else {
+        // create metric type
+        const metricType: MetricType = new MetricType();
+        metricType.name = metricName;
+        metricType.projectId = data.projectId;
+        metricType.telemetryServices = [];
+
+        const telemetryServiceIds: Array<ObjectID> =
+          data.metricNameServiceNameMap[metricName] || [];
+
+        for (const telemetryServiceId of telemetryServiceIds) {
+          const telemetryService: TelemetryService = new TelemetryService();
+          telemetryService.id = telemetryServiceId;
+          metricType.telemetryServices!.push(telemetryService);
+        }
+
+        // save metric type
+        await MetricTypeService.create({
+          data: metricType,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    }
+  }
+
   @CaptureSpan()
   public static async indexAttributes(data: {
     attributes: Array<string>;