@oneuptime/common 8.0.5440 → 8.0.5466

package/Models/DatabaseModels/StatusPage.ts

@@ -2331,4 +2331,84 @@ export default class StatusPage extends BaseModel {
     create: PlanType.Free,
   })
   public ipWhitelist?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectStatusPage,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectStatusPage,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectStatusPage,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Enable Embedded Overall Status Badge",
+    description:
+      "Enable embedded overall status badge that can be displayed on external websites?",
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: false,
+    nullable: false,
+  })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Growth,
+    create: PlanType.Free,
+  })
+  public enableEmbeddedOverallStatus?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectStatusPage,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectStatusPage,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectStatusPage,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    required: false,
+    title: "Embedded Overall Status Token",
+    description:
+      "Security token required to access the embedded overall status badge. This token must be provided in the URL.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+  })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Growth,
+    create: PlanType.Free,
+  })
+  public embeddedOverallStatusToken?: string = undefined;
 }

package/Models/DatabaseModels/TelemetryUsageBilling.ts

@@ -39,7 +39,7 @@ export const DEFAULT_RETENTION_IN_DAYS: number = 15;
   pluralName: "Telemetry Usage Billings",
   icon: IconProp.Billing,
   tableDescription:
-    "Stores historical usage billing data for your telemetry data like Logs, Metrics, and Traces.",
+    "Stores historical usage billing data for your telemetry data like Logs, Metrics, Traces, and Exceptions.",
 })
 @Entity({
   name: "TelemetryUsageBilling",

package/Server/API/StatusPageAPI.ts

@@ -276,6 +276,142 @@ export default class StatusPageAPI extends BaseAPI<
       },
     );
 
+    // embedded overall status badge api
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/badge/:statusPageId`,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        try {
+          const statusPageId: ObjectID = new ObjectID(
+            req.params["statusPageId"] as string,
+          );
+
+          const token: string = req.query["token"] as string;
+
+          if (!token) {
+            return res.status(400).send("Token is required");
+          }
+
+          // Fetch status page with security token
+          const statusPage: StatusPage | null =
+            await StatusPageService.findOneBy({
+              query: {
+                _id: statusPageId,
+                enableEmbeddedOverallStatus: true,
+                embeddedOverallStatusToken: token,
+              },
+              select: {
+                _id: true,
+                projectId: true,
+                downtimeMonitorStatuses: {
+                  _id: true,
+                },
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!statusPage) {
+            return res.status(404).send("Status badge not found or disabled");
+          }
+
+          // Get status page resources and current statuses
+          const statusPageResources: Array<StatusPageResource> =
+            await StatusPageResourceService.findBy({
+              query: {
+                statusPageId: statusPageId,
+              },
+              select: {
+                _id: true,
+                monitor: {
+                  _id: true,
+                  currentMonitorStatusId: true,
+                },
+                monitorGroupId: true,
+              },
+              limit: LIMIT_PER_PROJECT,
+              skip: 0,
+              props: {
+                isRoot: true,
+              },
+            });
+
+          // Get monitor statuses
+          const monitorStatuses: Array<MonitorStatus> =
+            await MonitorStatusService.findBy({
+              query: {
+                projectId: statusPage.projectId!,
+              },
+              select: {
+                _id: true,
+                name: true,
+                color: true,
+                priority: true,
+                isOperationalState: true,
+              },
+              sort: {
+                priority: SortOrder.Ascending,
+              },
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
+              props: {
+                isRoot: true,
+              },
+            });
+
+          // Get monitor group current statuses
+          const monitorGroupCurrentStatuses: Dictionary<ObjectID> =
+            await StatusPageService.getMonitorGroupCurrentStatuses({
+              statusPageResources,
+              monitorStatuses,
+            });
+
+          // Calculate overall status
+          const overallStatus: MonitorStatus | null =
+            StatusPageService.getOverallMonitorStatus({
+              statusPageResources,
+              monitorStatuses,
+              monitorGroupCurrentStatuses,
+            });
+
+          // Generate SVG badge
+          const statusName: string = overallStatus?.name || "Unknown";
+          const statusColor: string =
+            overallStatus?.color?.toString() || "#808080";
+
+          const svg: string = `<svg xmlns="http://www.w3.org/2000/svg" width="150" height="20">
+  <linearGradient id="b" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="a">
+    <rect width="150" height="20" rx="3" fill="#fff"/>
+  </mask>
+  <g mask="url(#a)">
+    <path fill="#555" d="M0 0h50v20H0z"/>
+    <path fill="${statusColor}" d="M50 0h100v20H50z"/>
+    <path fill="url(#b)" d="M0 0h150v20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="25" y="15" fill="#010101" fill-opacity=".3">status</text>
+    <text x="25" y="14">status</text>
+    <text x="100" y="15" fill="#010101" fill-opacity=".3">${statusName}</text>
+    <text x="100" y="14">${statusName}</text>
+  </g>
+</svg>`;
+
+          res.setHeader("Content-Type", "image/svg+xml");
+          res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+          return res.send(svg);
+        } catch (err) {
+          logger.error(err);
+          return res.status(500).send("Internal Server Error");
+        }
+      },
+    );
+
     // confirm subscription api
     this.router.get(
       `${new this.entityType()
@@ -1392,11 +1528,11 @@ export default class StatusPageAPI extends BaseAPI<
             });
 
           const overallStatus: MonitorStatus | null =
-            this.getOverallMonitorStatus(
+            StatusPageService.getOverallMonitorStatus({
               statusPageResources,
               monitorStatuses,
               monitorGroupCurrentStatuses,
-            );
+            });
 
           const response: JSONObject = {
             overallStatus: overallStatus
@@ -3099,56 +3235,6 @@ export default class StatusPageAPI extends BaseAPI<
     return response;
   }
 
-  public getOverallMonitorStatus(
-    statusPageResources: Array<StatusPageResource>,
-    monitorStatuses: Array<MonitorStatus>,
-    monitorGroupCurrentStatuses: Dictionary<ObjectID>,
-  ): MonitorStatus | null {
-    let currentStatus: MonitorStatus | null =
-      monitorStatuses.length > 0 && monitorStatuses[0]
-        ? monitorStatuses[0]
-        : null;
-
-    const dict: Dictionary<number> = {};
-
-    for (const resource of statusPageResources) {
-      if (resource.monitor?.currentMonitorStatusId) {
-        if (
-          !Object.keys(dict).includes(
-            resource.monitor?.currentMonitorStatusId.toString() || "",
-          )
-        ) {
-          dict[resource.monitor?.currentMonitorStatusId?.toString()] = 1;
-        } else {
-          dict[resource.monitor!.currentMonitorStatusId!.toString()]!++;
-        }
-      }
-    }
-
-    // check status of monitor groups.
-
-    for (const groupId in monitorGroupCurrentStatuses) {
-      const statusId: ObjectID | undefined =
-        monitorGroupCurrentStatuses[groupId];
-
-      if (statusId) {
-        if (!Object.keys(dict).includes(statusId.toString() || "")) {
-          dict[statusId.toString()] = 1;
-        } else {
-          dict[statusId.toString()]!++;
-        }
-      }
-    }
-
-    for (const monitorStatus of monitorStatuses) {
-      if (monitorStatus._id && dict[monitorStatus._id]) {
-        currentStatus = monitorStatus;
-      }
-    }
-
-    return currentStatus;
-  }
-
   @CaptureSpan()
   public async getStatusPageResourcesAndTimelines(data: {
     statusPageId: ObjectID;

package/Server/EnvironmentConfig.ts

@@ -23,6 +23,25 @@ export const getAllEnvVars: () => JSONObject = (): JSONObject => {
   return process.env;
 };
 
+const parsePositiveNumberFromEnv: (
+  envKey: string,
+  fallback: number,
+) => number = (envKey: string, fallback: number): number => {
+  const rawValue: string | undefined = process.env[envKey];
+
+  if (!rawValue) {
+    return fallback;
+  }
+
+  const parsedValue: number = parseFloat(rawValue);
+
+  if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+    return fallback;
+  }
+
+  return parsedValue;
+};
+
 export const IsBillingEnabled: boolean = BillingConfig.IsBillingEnabled;
 export const BillingPublicKey: string = BillingConfig.BillingPublicKey;
 export const BillingPrivateKey: string = BillingConfig.BillingPrivateKey;
@@ -346,6 +365,24 @@ export const DocsClientUrl: URL = new URL(
 export const DisableTelemetry: boolean =
   process.env["DISABLE_TELEMETRY"] === "true";
 
+export const AverageSpanRowSizeInBytes: number = parsePositiveNumberFromEnv(
+  "AVERAGE_SPAN_ROW_SIZE_IN_BYTES",
+  1024,
+);
+
+export const AverageLogRowSizeInBytes: number = parsePositiveNumberFromEnv(
+  "AVERAGE_LOG_ROW_SIZE_IN_BYTES",
+  1024,
+);
+
+export const AverageMetricRowSizeInBytes: number = parsePositiveNumberFromEnv(
+  "AVERAGE_METRIC_ROW_SIZE_IN_BYTES",
+  1024,
+);
+
+export const AverageExceptionRowSizeInBytes: number =
+  parsePositiveNumberFromEnv("AVERAGE_EXCEPTION_ROW_SIZE_IN_BYTES", 1024);
+
 export const SlackAppClientId: string | null =
   process.env["SLACK_APP_CLIENT_ID"] || null;
 export const SlackAppClientSecret: string | null =

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

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1761232578396 implements MigrationInterface {
+  public name = "MigrationName1761232578396";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "enableEmbeddedOverallStatus" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "embeddedOverallStatusToken" character varying(100)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_350d2250fb17e0dc10663de72a" ON "StatusPage" ("embeddedOverallStatusToken") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_350d2250fb17e0dc10663de72a"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "embeddedOverallStatusToken"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "enableEmbeddedOverallStatus"`,
+    );
+  }
+}

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

@@ -177,6 +177,7 @@ import { RenameUserTwoFactorAuthToUserTotpAuth1759234532998 } from "./1759234532
 import { MigrationName1759943124812 } from "./1759943124812-MigrationName";
 import { MigrationName1760345757975 } from "./1760345757975-MigrationName";
 import { MigrationName1760357680881 } from "./1760357680881-MigrationName";
+import { MigrationName1761232578396 } from "./1761232578396-MigrationName";
 
 export default [
   InitialMigration,
@@ -358,4 +359,5 @@ export default [
   MigrationName1759943124812,
   MigrationName1760345757975,
   MigrationName1760357680881,
+  MigrationName1761232578396,
 ];

package/Server/Services/AnalyticsDatabaseService.ts

@@ -42,6 +42,7 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import Exception from "../../Types/Exception/Exception";
+import ExceptionCode from "../../Types/Exception/ExceptionCode";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
@@ -66,7 +67,7 @@ export default class AnalyticsDatabaseService<
   public modelType!: { new (): TBaseModel };
   public database!: ClickhouseDatabase;
   public model!: TBaseModel;
-  public databaseClient!: ClickhouseClient;
+  public databaseClient!: ClickhouseClient | null;
   public statementGenerator!: StatementGenerator<TBaseModel>;
 
   public constructor(data: {
@@ -82,7 +83,7 @@ export default class AnalyticsDatabaseService<
       this.database = ClickhouseAppInstance; // default database
     }
 
-    this.databaseClient = this.database.getDataSource() as ClickhouseClient;
+    this.databaseClient = this.database.getDataSource();
 
     this.statementGenerator = new StatementGenerator<TBaseModel>({
       modelType: this.modelType,
@@ -90,6 +91,46 @@ export default class AnalyticsDatabaseService<
     });
   }
 
+  @CaptureSpan()
+  public async insertJsonRows(rows: Array<JSONObject>): Promise<void> {
+    if (!rows || rows.length === 0) {
+      return;
+    }
+
+    const client: ClickhouseClient = this.getDatabaseClient();
+
+    const tableName: string = this.model.tableName;
+
+    if (!tableName) {
+      throw new Exception(
+        ExceptionCode.BadDataException,
+        "Analytics model table name not configured",
+      );
+    }
+
+    try {
+      await client.insert({
+        table: tableName,
+        values: rows,
+        format: "JSONEachRow",
+        clickhouse_settings: {
+          async_insert: 1,
+          wait_for_async_insert: 0,
+        },
+      });
+
+      logger.debug(
+        `ClickHouse insert succeeded for table ${tableName} at ${OneUptimeDate.toString(OneUptimeDate.getCurrentDate())}`,
+      );
+    } catch (error) {
+      logger.error(
+        `ClickHouse insert failed for table ${tableName} at ${OneUptimeDate.toString(OneUptimeDate.getCurrentDate())}`,
+      );
+      logger.error(error);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   public async doesColumnExistInDatabase(columnName: string): Promise<boolean> {
     const statement: string =
@@ -807,23 +848,21 @@ export default class AnalyticsDatabaseService<
 
   public useDefaultDatabase(): void {
     this.database = ClickhouseAppInstance;
-    this.databaseClient = this.database.getDataSource() as ClickhouseClient;
+    this.databaseClient = this.database.getDataSource();
   }
 
   @CaptureSpan()
   public async execute(
     statement: Statement | string
   ): Promise<ExecResult<Stream>> {
-    if (!this.databaseClient) {
-      this.useDefaultDatabase();
-    }
+    const client: ClickhouseClient = this.getDatabaseClient();
 
     const query: string =
       statement instanceof Statement ? statement.query : statement;
     const queryParams: Record<string, unknown> | undefined =
       statement instanceof Statement ? statement.query_params : undefined;
 
-    return (await this.databaseClient.exec({
+    return (await client.exec({
       query: query,
       query_params: queryParams || (undefined as any), // undefined is not specified in the type for query_params, but its ok to pass undefined.
     })) as ExecResult<Stream>;
@@ -833,22 +872,43 @@ export default class AnalyticsDatabaseService<
   public async executeQuery(
     statement: Statement | string
   ): Promise<ResultSet<"JSON">> {
-    if (!this.databaseClient) {
-      this.useDefaultDatabase();
-    }
+    const client: ClickhouseClient = this.getDatabaseClient();
 
     const query: string =
       statement instanceof Statement ? statement.query : statement;
     const queryParams: Record<string, unknown> | undefined =
       statement instanceof Statement ? statement.query_params : undefined;
 
-    return await this.databaseClient.query({
+    return await client.query({
       query: query,
       format: "JSON",
       query_params: queryParams || (undefined as any), // undefined is not specified in the type for query_params, but its ok to pass undefined.
     });
   }
 
+  private getDatabaseClient(): ClickhouseClient {
+    /*
+     * Refresh the ClickHouse client lazily so services created before the
+     * ClickHouse connection was established pick up the live client.
+     */
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+
+    if (!this.databaseClient && this.database) {
+      this.databaseClient = this.database.getDataSource();
+    }
+
+    if (!this.databaseClient) {
+      throw new Exception(
+        ExceptionCode.DatabaseNotConnectedException,
+        "ClickHouse client is not connected",
+      );
+    }
+
+    return this.databaseClient;
+  }
+
   protected async onUpdateSuccess(
     onUpdate: OnUpdate<TBaseModel>,
     _updatedItemIds: Array<ObjectID>

package/Server/Services/OpenTelemetryIngestService.ts

@@ -4,11 +4,6 @@ import ObjectID from "../../Types/ObjectID";
 import Metric, {
   AggregationTemporality,
 } from "../../Models/AnalyticsModels/Metric";
-import Dictionary from "../../Types/Dictionary";
-import ProductType from "../../Types/MeteredPlan/ProductType";
-import { IsBillingEnabled } from "../../Server/EnvironmentConfig";
-import TelemetryUsageBillingService from "../../Server/Services/TelemetryUsageBillingService";
-import logger from "../../Server/Utils/Logger";
 import TelemetryService from "../../Models/DatabaseModels/TelemetryService";
 import TelemetryServiceService from "../../Server/Services/TelemetryServiceService";
 import { DEFAULT_RETENTION_IN_DAYS } from "../../Models/DatabaseModels/TelemetryUsageBilling";
@@ -20,10 +15,9 @@ export enum OtelAggregationTemporality {
   Delta = "AGGREGATION_TEMPORALITY_DELTA",
 }
 
-export interface TelemetryServiceDataIngested {
+export interface TelemetryServiceMetadata {
   serviceName: string;
   serviceId: ObjectID;
-  dataIngestedInGB: number;
   dataRententionInDays: number;
 }
 
@@ -80,38 +74,6 @@ export default class OTelIngestService {
         service.retainTelemetryDataForDays || DEFAULT_RETENTION_IN_DAYS,
     };
   }
-
-  @CaptureSpan()
-  public static async recordDataIngestedUsgaeBilling(data: {
-    services: Dictionary<TelemetryServiceDataIngested>;
-    projectId: ObjectID;
-    productType: ProductType;
-  }): Promise<void> {
-    if (!IsBillingEnabled) {
-      return;
-    }
-
-    for (const serviceName in data.services) {
-      const serviceData: TelemetryServiceDataIngested | undefined =
-        data.services[serviceName];
-
-      if (!serviceData) {
-        continue;
-      }
-
-      TelemetryUsageBillingService.updateUsageBilling({
-        projectId: data.projectId,
-        productType: data.productType,
-        dataIngestedInGB: serviceData.dataIngestedInGB || 0,
-        telemetryServiceId: serviceData.serviceId,
-        retentionInDays: serviceData.dataRententionInDays,
-      }).catch((err: Error) => {
-        logger.error("Failed to update usage billing for OTel");
-        logger.error(err);
-      });
-    }
-  }
-
   @CaptureSpan()
   public static getMetricFromDatapoint(data: {
     dbMetric: Metric;