@oneuptime/common 8.0.5438 → 8.0.5462

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/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,21 @@ 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 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/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;

package/Server/Services/StatusPageService.ts

@@ -1150,5 +1150,122 @@ export class Service extends DatabaseService<StatusPage> {
       },
     );
   }
+
+  @CaptureSpan()
+  public async getMonitorGroupCurrentStatuses(data: {
+    statusPageResources: Array<StatusPageResource>;
+    monitorStatuses: Array<MonitorStatus>;
+  }): Promise<Dictionary<ObjectID>> {
+    const monitorGroupCurrentStatuses: Dictionary<ObjectID> = {};
+
+    for (const resource of data.statusPageResources) {
+      if (resource.monitorGroupId) {
+        const monitorGroupResources: Array<MonitorGroupResource> =
+          await MonitorGroupResourceService.findBy({
+            query: {
+              monitorGroupId: resource.monitorGroupId,
+            },
+            select: {
+              monitorId: true,
+              monitor: {
+                currentMonitorStatusId: true,
+              },
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const statuses: Array<ObjectID> = monitorGroupResources
+          .filter((item: MonitorGroupResource) => {
+            return (
+              item.monitor &&
+              item.monitor.currentMonitorStatusId &&
+              item.monitorId
+            );
+          })
+          .map((item: MonitorGroupResource) => {
+            return item.monitor!.currentMonitorStatusId!;
+          });
+
+        let worstStatus: MonitorStatus | null = null;
+
+        for (const statusId of statuses) {
+          const status: MonitorStatus | undefined = data.monitorStatuses.find(
+            (status: MonitorStatus) => {
+              return status._id?.toString() === statusId.toString();
+            },
+          );
+
+          if (
+            status &&
+            (!worstStatus || status.priority! < worstStatus.priority!)
+          ) {
+            worstStatus = status;
+          }
+        }
+
+        if (worstStatus && worstStatus._id) {
+          monitorGroupCurrentStatuses[resource.monitorGroupId.toString()] =
+            new ObjectID(worstStatus._id);
+        }
+      }
+    }
+
+    return monitorGroupCurrentStatuses;
+  }
+
+  @CaptureSpan()
+  public getOverallMonitorStatus(data: {
+    statusPageResources: Array<StatusPageResource>;
+    monitorStatuses: Array<MonitorStatus>;
+    monitorGroupCurrentStatuses: Dictionary<ObjectID>;
+  }): MonitorStatus | null {
+    let currentStatus: MonitorStatus | null =
+      data.monitorStatuses.length > 0 && data.monitorStatuses[0]
+        ? data.monitorStatuses[0]
+        : null;
+
+    const dict: Dictionary<number> = {};
+
+    for (const resource of data.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 data.monitorGroupCurrentStatuses) {
+      const statusId: ObjectID | undefined =
+        data.monitorGroupCurrentStatuses[groupId];
+
+      if (statusId) {
+        if (!Object.keys(dict).includes(statusId.toString() || "")) {
+          dict[statusId.toString()] = 1;
+        } else {
+          dict[statusId.toString()]!++;
+        }
+      }
+    }
+
+    for (const monitorStatus of data.monitorStatuses) {
+      if (monitorStatus._id && dict[monitorStatus._id]) {
+        currentStatus = monitorStatus;
+      }
+    }
+
+    return currentStatus;
+  }
 }
 export default new Service();