@oneuptime/common 7.0.3225 → 7.0.3233

package/Models/AnalyticsModels/Index.ts

@@ -1,7 +1,6 @@
 import AnalyticsBaseModel from "./AnalyticsBaseModel/AnalyticsBaseModel";
 import Log from "./Log";
 import Metric from "./Metric";
-import MonitorMetricsByMinute from "./MonitorMetricsByMinute";
 import Span from "./Span";
 import TelemetryAttribute from "./TelemetryAttribute";
 import ExceptionInstance from "./ExceptionInstance";
@@ -10,7 +9,6 @@ const AnalyticsModels: Array<{ new (): AnalyticsBaseModel }> = [
   Log,
   Span,
   Metric,
-  MonitorMetricsByMinute,
   TelemetryAttribute,
   ExceptionInstance,
 ];

package/Models/AnalyticsModels/Metric.ts

@@ -19,6 +19,11 @@ export enum MetricPointType {
   ExponentialHistogram = "ExponentialHistogram",
 }
 
+export enum ServiceType {
+  OpenTelemetry = "OpenTelemetry",
+  Monitor = "Monitor",
+}
+
 export default class Metric extends AnalyticsBaseModel {
   public constructor() {
     super({
@@ -78,10 +83,11 @@ export default class Metric extends AnalyticsBaseModel {
           },
         }),
 
+        // this can also be the monitor id or the telemetry service id.
         new AnalyticsTableColumn({
           key: "serviceId",
           title: "Service ID",
-          description: "ID of the Service which created the log",
+          description: "ID of the Service which created the Metric",
           required: true,
           type: TableColumnType.ObjectID,
           accessControl: {
@@ -101,6 +107,30 @@ export default class Metric extends AnalyticsBaseModel {
           },
         }),
 
+        // this can also be the monitor id or the telemetry service id.
+        new AnalyticsTableColumn({
+          key: "serviceType",
+          title: "Service Type",
+          description: "Type of the service that this telemetry belongs to",
+          required: false,
+          type: TableColumnType.Text,
+          accessControl: {
+            read: [
+              Permission.ProjectOwner,
+              Permission.ProjectAdmin,
+              Permission.ProjectMember,
+              Permission.ReadTelemetryServiceLog,
+            ],
+            create: [
+              Permission.ProjectOwner,
+              Permission.ProjectAdmin,
+              Permission.ProjectMember,
+              Permission.CreateTelemetryServiceLog,
+            ],
+            update: [],
+          },
+        }),
+
         // add name and description
 
         new AnalyticsTableColumn({
@@ -539,6 +569,10 @@ export default class Metric extends AnalyticsBaseModel {
     return this.getColumnValue("serviceId") as ObjectID | undefined;
   }
 
+  public get serviceType(): ServiceType | undefined {
+    return this.getColumnValue("serviceType") as ServiceType | undefined;
+  }
+
   public get name(): string | undefined {
     return this.getColumnValue("name") as string | undefined;
   }
@@ -595,6 +629,10 @@ export default class Metric extends AnalyticsBaseModel {
     this.setColumnValue("serviceId", v);
   }
 
+  public set serviceType(v: ServiceType | undefined) {
+    this.setColumnValue("serviceType", v);
+  }
+
   public get time(): Date | undefined {
     return this.getColumnValue("time") as Date | undefined;
   }

package/Models/DatabaseModels/Alert.ts

@@ -801,7 +801,6 @@ export default class Alert extends BaseModel {
     ],
     update: [],
   })
-  @Index()
   @TableColumn({
     type: TableColumnType.Markdown,
     required: false,

package/Models/DatabaseModels/Incident.ts

@@ -855,7 +855,6 @@ export default class Incident extends BaseModel {
     ],
     update: [],
   })
-  @Index()
   @TableColumn({
     type: TableColumnType.Markdown,
     required: false,

package/Models/DatabaseModels/IncidentStateTimeline.ts

@@ -507,7 +507,6 @@ export default class IncidentStateTimeline extends BaseModel {
     ],
     update: [],
   })
-  @Index()
   @TableColumn({
     type: TableColumnType.Markdown,
     required: false,

package/Models/DatabaseModels/MonitorStatusTimeline.ts

@@ -455,7 +455,6 @@ export default class MonitorStatusTimeline extends BaseModel {
     ],
     update: [],
   })
-  @Index()
   @TableColumn({
     type: TableColumnType.Markdown,
     required: false,

package/Server/API/BaseAnalyticsAPI.ts

@@ -291,6 +291,17 @@ export default class BaseAnalyticsAPI<
       ) as any;
     }
 
+    let groupBy: GroupBy<AnalyticsDataModel> | null =
+      req.body["groupBy"] || null;
+
+    if (groupBy && Object.keys(groupBy).length > 0) {
+      groupBy = JSONFunctions.deserialize(groupBy as JSONObject) as any;
+    }
+
+    if (groupBy && Object.keys(groupBy).length === 0) {
+      groupBy = null;
+    }
+
     if (!aggregateBy) {
       throw new BadRequestException("AggregateBy is required");
     }

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1731433043136 implements MigrationInterface {
+  public name = "MigrationName1731433043136";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_5218e92f700d91afe6a8db79cb"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_5218e92f700d91afe6a8db79cb" ON "Incident" ("rootCause") `,
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1731433309124 implements MigrationInterface {
+  public name = "MigrationName1731433309124";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_fc40ea6a9ad55f29bca4f4a15d"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_fc40ea6a9ad55f29bca4f4a15d" ON "Alert" ("rootCause") `,
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1731435267537 implements MigrationInterface {
+  public name = "MigrationName1731435267537";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_01ac1d1ef9e72aeb6dac6575dd"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_01ac1d1ef9e72aeb6dac6575dd" ON "MonitorStatusTimeline" ("rootCause") `,
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1731435514287 implements MigrationInterface {
+  public name = "MigrationName1731435514287";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_7db6b1a8fbbc9eb44c2e7f5047"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_7db6b1a8fbbc9eb44c2e7f5047" ON "IncidentStateTimeline" ("rootCause") `,
+    );
+  }
+}

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

@@ -78,6 +78,10 @@ import { MigrationName1729682875503 } from "./1729682875503-MigrationName";
 import { MigrationName1730117995642 } from "./1730117995642-MigrationName";
 import { MigrationName1730209089495 } from "./1730209089495-MigrationName";
 import { MigrationName1730223198692 } from "./1730223198692-MigrationName";
+import { MigrationName1731433043136 } from "./1731433043136-MigrationName";
+import { MigrationName1731433309124 } from "./1731433309124-MigrationName";
+import { MigrationName1731435267537 } from "./1731435267537-MigrationName";
+import { MigrationName1731435514287 } from "./1731435514287-MigrationName";
 
 export default [
   InitialMigration,
@@ -160,4 +164,8 @@ export default [
   MigrationName1730117995642,
   MigrationName1730209089495,
   MigrationName1730223198692,
+  MigrationName1731433043136,
+  MigrationName1731433309124,
+  MigrationName1731435267537,
+  MigrationName1731435514287,
 ];

package/Server/Services/AnalyticsDatabaseService.ts

@@ -259,6 +259,11 @@ export default class AnalyticsDatabaseService<
 
       // convert date column from string to date.
 
+      const groupByColumnName: keyof TBaseModel | undefined =
+        aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0
+          ? (Object.keys(aggregateBy.groupBy)[0] as keyof TBaseModel)
+          : undefined;
+
       for (const item of items) {
         if (
           !(item as JSONObject)[
@@ -277,6 +282,9 @@ export default class AnalyticsDatabaseService<
           value: (item as JSONObject)[
             aggregateBy.aggregateColumnName as string
           ] as number,
+          [groupByColumnName as string]: (item as JSONObject)[
+            groupByColumnName as string
+          ],
         };
 
         aggregatedItems.push(aggregatedModel);
@@ -457,7 +465,7 @@ export default class AnalyticsDatabaseService<
                 count()
             FROM ${databaseName}.${this.model.tableName}
             WHERE TRUE `.append(whereStatement);
-    
+
 
     if (countBy.groupBy && Object.keys(countBy.groupBy).length > 0) {
       statement.append(
@@ -519,9 +527,11 @@ export default class AnalyticsDatabaseService<
     statement.append(SQL` FROM ${databaseName}.${this.model.tableName}`);
     statement.append(SQL` WHERE TRUE `).append(whereStatement);
 
-   
-      statement.append(SQL` GROUP BY `).append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
-   
+    statement.append(SQL` GROUP BY `).append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+
+    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+      statement.append(SQL` , `).append(this.statementGenerator.toGroupByStatement(aggregateBy.groupBy));
+    }
 
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
@@ -538,7 +548,7 @@ export default class AnalyticsDatabaseService<
     }}
         `);
 
-    
+
 
     logger.debug(`${this.model.tableName} Aggregate Statement`);
     logger.debug(statement);
@@ -604,7 +614,7 @@ export default class AnalyticsDatabaseService<
     }}
         `);
 
-    
+
 
     logger.debug(`${this.model.tableName} Find Statement`);
     logger.debug(statement);
@@ -626,7 +636,7 @@ export default class AnalyticsDatabaseService<
     const statement: Statement = SQL`
             ALTER TABLE ${databaseName}.${this.model.tableName}
             DELETE WHERE TRUE `.append(whereStatement);
-    
+
 
     logger.debug(`${this.model.tableName} Delete Statement`);
     logger.debug(statement);

package/Server/Services/DatabaseService.ts

@@ -437,10 +437,10 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     const columns: Columns = this.model.getTableColumns();
 
     for (const columnName of columns.columns) {
-      if (this.model.isEntityColumn(columnName)) {
-        const tableColumnMetadata: TableColumnMetadata =
-          this.model.getTableColumnMetadata(columnName);
+      const tableColumnMetadata: TableColumnMetadata =
+        this.model.getTableColumnMetadata(columnName);
 
+      if (this.model.isEntityColumn(columnName)) {
         const columnValue: JSONValue = (data as any)[columnName];
 
         if (
@@ -507,6 +507,14 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
           (data as any)[columnName] = columnValue.toString();
         }
       }
+
+      // if its a Date column and if date is null then set it to null.
+      if (
+        (data as any)[columnName] === "" &&
+        tableColumnMetadata.type === TableColumnType.Date
+      ) {
+        (data as any)[columnName] = null;
+      }
     }
 
     // check createByUserId.

package/Server/Services/Index.ts

@@ -41,7 +41,6 @@ import MonitorGroupOwnerTeamService from "./MonitorGroupOwnerTeamService";
 import MonitorGroupOwnerUserService from "./MonitorGroupOwnerUserService";
 import MonitorGroupResourceService from "./MonitorGroupResourceService";
 import MonitorGroupService from "./MonitorGroupService";
-import MonitorMetricsByMinuteService from "./MonitorMetricsByMinuteService";
 import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
 import MonitorOwnerUserService from "./MonitorOwnerUserService";
 import MonitorProbeService from "./MonitorProbeService";
@@ -316,7 +315,6 @@ export const AnalyticsServices: Array<
   LogService,
   SpanService,
   MetricService,
-  MonitorMetricsByMinuteService,
   TelemetryAttributeService,
   ExceptionInstanceService,
 ];

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -18,16 +18,16 @@ export class AggregateUtil {
     if (diff <= 1000 * 60 * 60 * 3) {
       // if less than 3 hours, then get minute precision
       return AggregationInterval.Minute;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 3) {
+    } else if (diff <= 1000 * 60 * 60 * 24 * 7) {
       // 3 days
       return AggregationInterval.Hour;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 7 * 3) {
+    } else if (diff <= 1000 * 60 * 60 * 24 * 7 * 6) {
       // 3 weeks
       return AggregationInterval.Day;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 30 * 3) {
+    } else if (diff <= 1000 * 60 * 60 * 24 * 30 * 6) {
       // 3 months
       return AggregationInterval.Week;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 365 * 3) {
+    } else if (diff <= 1000 * 60 * 60 * 24 * 365 * 6) {
       // 3 years
       return AggregationInterval.Month;
     }

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -548,11 +548,25 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       `${aggregationMethod}(${aggregateBy.aggregateColumnName.toString()}) as ${aggregateBy.aggregateColumnName.toString()}, date_trunc('${aggregationInterval.toLowerCase()}', toStartOfInterval(${aggregateBy.aggregationTimestampColumnName.toString()}, INTERVAL 1 ${aggregationInterval.toLowerCase()})) as ${aggregateBy.aggregationTimestampColumnName.toString()}`,
     );
 
+    const columns: Array<string> = [
+      aggregateBy.aggregateColumnName.toString(),
+      aggregateBy.aggregationTimestampColumnName.toString(),
+    ];
+
+    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+      const groupByStatement: Statement = this.toGroupByStatement(
+        aggregateBy.groupBy,
+      );
+      selectStatement.append(SQL`, `).append(groupByStatement);
+
+      // add to columns.
+      for (const key in aggregateBy.groupBy) {
+        columns.push(key);
+      }
+    }
+
     return {
-      columns: [
-        aggregateBy.aggregateColumnName.toString(),
-        aggregateBy.aggregationTimestampColumnName.toString(),
-      ],
+      columns: columns,
       statement: selectStatement,
     };
   }

package/Server/Utils/Browser.ts

@@ -0,0 +1,194 @@
+import {
+  Page as PlaywrightPage,
+  Browser as PlaywrightBrowser,
+  chromium,
+  firefox,
+} from "playwright";
+import LocalFile from "./LocalFile";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ScreenSizeType from "../../Types/ScreenSizeType";
+import BrowserType from "../../Types/BrowserType";
+import logger from "./Logger";
+
+export type Page = PlaywrightPage;
+export type Browser = PlaywrightBrowser;
+
+export default class BrowserUtil {
+  public static async convertHtmlToBase64Screenshot(data: {
+    html: string;
+  }): Promise<string | null> {
+    try {
+      const html: string = data.html;
+
+      const pageAndBrowser: {
+        page: Page;
+        browser: Browser;
+      } = await BrowserUtil.getPageByBrowserType({
+        browserType: BrowserType.Chromium,
+        screenSizeType: ScreenSizeType.Desktop,
+      });
+
+      const page: Page = pageAndBrowser.page;
+      const browser: Browser = pageAndBrowser.browser;
+      await page.setContent(html, {
+        waitUntil: "domcontentloaded",
+      });
+      const screenshot: Buffer = await page.screenshot({ type: "png" });
+
+      await browser.close();
+
+      return screenshot.toString("base64");
+    } catch (e) {
+      logger.debug(e);
+      return null;
+    }
+  }
+
+  public static async getPageByBrowserType(data: {
+    browserType: BrowserType;
+    screenSizeType: ScreenSizeType;
+  }): Promise<{
+    page: Page;
+    browser: Browser;
+  }> {
+    const viewport: {
+      height: number;
+      width: number;
+    } = BrowserUtil.getViewportHeightAndWidth({
+      screenSizeType: data.screenSizeType,
+    });
+
+    let page: Page | null = null;
+    let browser: Browser | null = null;
+
+    if (data.browserType === BrowserType.Chromium) {
+      browser = await chromium.launch({
+        executablePath: await BrowserUtil.getChromeExecutablePath(),
+      });
+      page = await browser.newPage();
+    }
+
+    if (data.browserType === BrowserType.Firefox) {
+      browser = await firefox.launch({
+        executablePath: await BrowserUtil.getFirefoxExecutablePath(),
+      });
+      page = await browser.newPage();
+    }
+
+    // if (data.browserType === BrowserType.Webkit) {
+    //     browser = await webkit.launch();
+    //     page = await browser.newPage();
+    // }
+
+    await page?.setViewportSize({
+      width: viewport.width,
+      height: viewport.height,
+    });
+
+    if (!browser) {
+      throw new BadDataException("Invalid Browser Type.");
+    }
+
+    if (!page) {
+      // close the browser if page is not created
+      await browser.close();
+      throw new BadDataException("Invalid Browser Type.");
+    }
+
+    return {
+      page: page,
+      browser: browser,
+    };
+  }
+
+  public static getViewportHeightAndWidth(options: {
+    screenSizeType: ScreenSizeType;
+  }): {
+    height: number;
+    width: number;
+  } {
+    let viewPortHeight: number = 0;
+    let viewPortWidth: number = 0;
+
+    switch (options.screenSizeType) {
+      case ScreenSizeType.Desktop:
+        viewPortHeight = 1080;
+        viewPortWidth = 1920;
+        break;
+      case ScreenSizeType.Mobile:
+        viewPortHeight = 640;
+        viewPortWidth = 360;
+        break;
+      case ScreenSizeType.Tablet:
+        viewPortHeight = 768;
+        viewPortWidth = 1024;
+        break;
+      default:
+        viewPortHeight = 1080;
+        viewPortWidth = 1920;
+        break;
+    }
+
+    return { height: viewPortHeight, width: viewPortWidth };
+  }
+
+  public static async getChromeExecutablePath(): Promise<string> {
+    const doesDirectoryExist: boolean = await LocalFile.doesDirectoryExist(
+      "/root/.cache/ms-playwright",
+    );
+    if (!doesDirectoryExist) {
+      throw new BadDataException("Chrome executable path not found.");
+    }
+
+    // get list of files in the directory
+    const directories: string[] = await LocalFile.getListOfDirectories(
+      "/root/.cache/ms-playwright",
+    );
+
+    if (directories.length === 0) {
+      throw new BadDataException("Chrome executable path not found.");
+    }
+
+    const chromeInstallationName: string | undefined = directories.find(
+      (directory: string) => {
+        return directory.includes("chromium");
+      },
+    );
+
+    if (!chromeInstallationName) {
+      throw new BadDataException("Chrome executable path not found.");
+    }
+
+    return `/root/.cache/ms-playwright/${chromeInstallationName}/chrome-linux/chrome`;
+  }
+
+  public static async getFirefoxExecutablePath(): Promise<string> {
+    const doesDirectoryExist: boolean = await LocalFile.doesDirectoryExist(
+      "/root/.cache/ms-playwright",
+    );
+    if (!doesDirectoryExist) {
+      throw new BadDataException("Firefox executable path not found.");
+    }
+
+    // get list of files in the directory
+    const directories: string[] = await LocalFile.getListOfDirectories(
+      "/root/.cache/ms-playwright",
+    );
+
+    if (directories.length === 0) {
+      throw new BadDataException("Firefox executable path not found.");
+    }
+
+    const firefoxInstallationName: string | undefined = directories.find(
+      (directory: string) => {
+        return directory.includes("firefox");
+      },
+    );
+
+    if (!firefoxInstallationName) {
+      throw new BadDataException("Firefox executable path not found.");
+    }
+
+    return `/root/.cache/ms-playwright/${firefoxInstallationName}/firefox/firefox`;
+  }
+}

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -544,6 +544,9 @@ export default class CompareCriteria {
       case FilterType.NotEqualTo:
         message += ` not equal to ${data.threshold}. `;
         break;
+      case FilterType.EqualTo:
+        message += ` equal to ${data.threshold}. `;
+        break;
       case FilterType.Contains:
         message += ` contains ${data.threshold}. `;
         break;