@oneuptime/common 10.0.85 → 10.0.88

package/Models/DatabaseModels/EnterpriseLicense.ts

@@ -101,4 +101,58 @@ export default class EnterpriseLicense extends BaseModel {
     type: ColumnType.Number,
   })
   public annualContractValue?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "User Limit",
+    description:
+      "Maximum number of users allowed under this enterprise license.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Number,
+  })
+  public userLimit?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Current User Count",
+    description:
+      "Most recent user count reported by the customer's self-hosted installation.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Number,
+  })
+  public currentUserCount?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "User Count Updated At",
+    description:
+      "Timestamp of the most recent user count report from the customer's self-hosted installation.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Date,
+  })
+  public userCountUpdatedAt?: Date = undefined;
 }

package/Models/DatabaseModels/GlobalConfig.ts

@@ -756,6 +756,57 @@ export default class GlobalConfig extends GlobalConfigModel {
   })
   public enterpriseLicenseToken?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Number,
+    title: "Enterprise License User Limit",
+    description:
+      "Maximum number of users permitted under the validated enterprise license.",
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: true,
+  })
+  public enterpriseLicenseUserLimit?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Number,
+    title: "Enterprise License Current User Count",
+    description:
+      "User count last reported to OneUptime for the validated enterprise license.",
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: true,
+  })
+  public enterpriseLicenseCurrentUserCount?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Enterprise License User Count Updated At",
+    description:
+      "Timestamp of the most recent user count report sent to OneUptime for the validated enterprise license.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public enterpriseLicenseUserCountUpdatedAt?: Date = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Server/API/EnterpriseLicenseAPI.ts

@@ -6,6 +6,7 @@ import EnterpriseLicenseService, {
 } from "../Services/EnterpriseLicenseService";
 import UserMiddleware from "../Middleware/UserAuthorization";
 import JSONWebToken from "../Utils/JsonWebToken";
+import OneUptimeDate from "../../Types/Date";
 import Response from "../Utils/Response";
 import {
   ExpressRequest,
@@ -52,6 +53,9 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
                 companyName: true,
                 expiresAt: true,
                 licenseKey: true,
+                userLimit: true,
+                currentUserCount: true,
+                userCountUpdatedAt: true,
               },
               props: {
                 isRoot: true,
@@ -80,6 +84,8 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             companyName: license.companyName || "",
             expiresAt: license.expiresAt.toISOString(),
             licenseKey: license.licenseKey || "",
+            userLimit:
+              typeof license.userLimit === "number" ? license.userLimit : null,
           };
 
           const token: string = JSONWebToken.signJsonPayload(
@@ -91,6 +97,14 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             companyName: payload["companyName"] as string,
             expiresAt: payload["expiresAt"] as string,
             licenseKey: payload["licenseKey"] as string,
+            userLimit: payload["userLimit"],
+            currentUserCount:
+              typeof license.currentUserCount === "number"
+                ? license.currentUserCount
+                : null,
+            userCountUpdatedAt: license.userCountUpdatedAt
+              ? license.userCountUpdatedAt.toISOString()
+              : null,
             token,
           });
         } catch (err) {
@@ -98,5 +112,74 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
         }
       },
     );
+
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/report-user-count`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const licenseKey: string | undefined = (
+            req.body["licenseKey"] as string | undefined
+          )?.trim();
+          const rawUserCount: unknown = req.body["userCount"];
+
+          if (!licenseKey) {
+            throw new BadDataException("License key is required");
+          }
+
+          const userCount: number = Number(rawUserCount);
+
+          if (
+            !Number.isFinite(userCount) ||
+            userCount < 0 ||
+            !Number.isInteger(userCount)
+          ) {
+            throw new BadDataException(
+              "userCount must be a non-negative integer",
+            );
+          }
+
+          const license: EnterpriseLicense | null =
+            await EnterpriseLicenseService.findOneBy({
+              query: {
+                licenseKey: licenseKey,
+              },
+              select: {
+                _id: true,
+                userLimit: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!license) {
+            throw new BadDataException("License key is invalid");
+          }
+
+          const reportedAt: Date = OneUptimeDate.getCurrentDate();
+
+          await EnterpriseLicenseService.updateOneById({
+            id: license.id!,
+            data: {
+              currentUserCount: userCount,
+              userCountUpdatedAt: reportedAt,
+            },
+            props: {
+              isRoot: true,
+              ignoreHooks: true,
+            },
+          });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            currentUserCount: userCount,
+            userCountUpdatedAt: reportedAt.toISOString(),
+            userLimit:
+              typeof license.userLimit === "number" ? license.userLimit : null,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
   }
 }

package/Server/API/GlobalConfigAPI.ts

@@ -67,6 +67,9 @@ export default class GlobalConfigAPI extends BaseAPI<
                 enterpriseLicenseExpiresAt: true,
                 enterpriseLicenseKey: true,
                 enterpriseLicenseToken: true,
+                enterpriseLicenseUserLimit: true,
+                enterpriseLicenseCurrentUserCount: true,
+                enterpriseLicenseUserCountUpdatedAt: true,
               },
               props: {
                 isRoot: true,
@@ -80,6 +83,17 @@ export default class GlobalConfigAPI extends BaseAPI<
               : null,
             licenseKey: config?.enterpriseLicenseKey || null,
             token: config?.enterpriseLicenseToken || null,
+            userLimit:
+              typeof config?.enterpriseLicenseUserLimit === "number"
+                ? config.enterpriseLicenseUserLimit
+                : null,
+            currentUserCount:
+              typeof config?.enterpriseLicenseCurrentUserCount === "number"
+                ? config.enterpriseLicenseCurrentUserCount
+                : null,
+            userCountUpdatedAt: config?.enterpriseLicenseUserCountUpdatedAt
+              ? config.enterpriseLicenseUserCountUpdatedAt.toISOString()
+              : null,
           };
 
           return Response.sendJsonObjectResponse(req, res, responseBody);
@@ -143,11 +157,38 @@ export default class GlobalConfigAPI extends BaseAPI<
             licenseExpiry = parsedDate;
           }
 
+          const userLimitRaw: unknown = payload["userLimit"];
+          const userLimit: number | null =
+            typeof userLimitRaw === "number" && Number.isFinite(userLimitRaw)
+              ? userLimitRaw
+              : null;
+
+          const currentUserCountRaw: unknown = payload["currentUserCount"];
+          const currentUserCount: number | null =
+            typeof currentUserCountRaw === "number" &&
+            Number.isFinite(currentUserCountRaw)
+              ? currentUserCountRaw
+              : null;
+
+          const userCountUpdatedAtRaw: string | undefined = payload[
+            "userCountUpdatedAt"
+          ] as string | undefined;
+          let userCountUpdatedAt: Date | null = null;
+          if (userCountUpdatedAtRaw) {
+            const parsedReportedAt: Date = new Date(userCountUpdatedAtRaw);
+            if (!Number.isNaN(parsedReportedAt.getTime())) {
+              userCountUpdatedAt = parsedReportedAt;
+            }
+          }
+
           const updatePayload: PartialEntity<GlobalConfig> = {
             enterpriseCompanyName: companyNameRaw || null,
             enterpriseLicenseKey: licenseKeyRaw || null,
             enterpriseLicenseExpiresAt: licenseExpiry || null,
             enterpriseLicenseToken: licenseToken || null,
+            enterpriseLicenseUserLimit: userLimit,
+            enterpriseLicenseCurrentUserCount: currentUserCount,
+            enterpriseLicenseUserCountUpdatedAt: userCountUpdatedAt,
           };
 
           const globalConfigId: ObjectID = ObjectID.getZeroObjectID();
@@ -193,6 +234,19 @@ export default class GlobalConfigAPI extends BaseAPI<
               newConfig.enterpriseLicenseExpiresAt = licenseExpiry;
             }
 
+            if (userLimit !== null) {
+              newConfig.enterpriseLicenseUserLimit = userLimit;
+            }
+
+            if (currentUserCount !== null) {
+              newConfig.enterpriseLicenseCurrentUserCount = currentUserCount;
+            }
+
+            if (userCountUpdatedAt) {
+              newConfig.enterpriseLicenseUserCountUpdatedAt =
+                userCountUpdatedAt;
+            }
+
             await GlobalConfigService.create({
               data: newConfig,
               props: {
@@ -207,6 +261,11 @@ export default class GlobalConfigAPI extends BaseAPI<
             expiresAt: licenseExpiry ? licenseExpiry.toISOString() : null,
             licenseKey: licenseKeyRaw || null,
             token: licenseToken || null,
+            userLimit: userLimit,
+            currentUserCount: currentUserCount,
+            userCountUpdatedAt: userCountUpdatedAt
+              ? userCountUpdatedAt.toISOString()
+              : null,
           });
         } catch (err) {
           next(err);

package/Server/API/TelemetryAPI.ts

@@ -80,6 +80,14 @@ router.post(
   },
 );
 
+router.post(
+  "/telemetry/logs/get-attribute-values",
+  UserMiddleware.getUserMiddleware,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    return getAttributeValues(req, res, next, TelemetryType.Log);
+  },
+);
+
 router.post(
   "/telemetry/traces/get-attributes",
   UserMiddleware.getUserMiddleware,
@@ -96,6 +104,22 @@ router.post(
   },
 );
 
+router.post(
+  "/telemetry/exceptions/get-attributes",
+  UserMiddleware.getUserMiddleware,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    return getAttributes(req, res, next, TelemetryType.Exception);
+  },
+);
+
+router.post(
+  "/telemetry/exceptions/get-attribute-values",
+  UserMiddleware.getUserMiddleware,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    return getAttributeValues(req, res, next, TelemetryType.Exception);
+  },
+);
+
 type GetAttributesFunction = (
   req: ExpressRequest,
   res: ExpressResponse,

package/Server/EnvironmentConfig.ts

@@ -162,6 +162,12 @@ export const ClusterKey: ObjectID = new ObjectID(
 
 export const HasClusterKey: boolean = Boolean(process.env["ONEUPTIME_SECRET"]);
 
+export const EnableQueueDashboard: boolean =
+  process.env["ENABLE_QUEUE_DASHBOARD"] === "true";
+
+export const QueueDashboardSecret: string =
+  process.env["QUEUE_DASHBOARD_SECRET"] || "";
+
 export const RegisterProbeKey: ObjectID = new ObjectID(
   process.env["REGISTER_PROBE_KEY"] || "secret",
 );
@@ -513,6 +519,10 @@ export const EnterpriseLicenseValidationUrl: URL = URL.fromString(
   "https://oneuptime.com/api/enterprise-license/validate",
 );
 
+export const EnterpriseLicenseUserCountReportUrl: URL = URL.fromString(
+  "https://oneuptime.com/api/enterprise-license/report-user-count",
+);
+
 // Inbound Email Configuration for Incoming Email Monitor
 export enum InboundEmailProviderType {
   SendGrid = "SendGrid",

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

@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1777629313843 implements MigrationInterface {
+  public name: string = "MigrationName1777629313843";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseUserLimit" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseCurrentUserCount" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseUserCountUpdatedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" ADD "userLimit" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" ADD "currentUserCount" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" ADD "userCountUpdatedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  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}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" DROP COLUMN "userCountUpdatedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" DROP COLUMN "currentUserCount"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" DROP COLUMN "userLimit"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseUserCountUpdatedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseCurrentUserCount"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseUserLimit"`,
+    );
+  }
+}

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

@@ -295,6 +295,7 @@ import { AddTelemetryRetentionSettings1777018175127 } from "./1777018175127-AddT
 import { AddMonitorTemplate1777201966799 } from "./1777201966799-AddMonitorTemplate";
 import { MigrationName1777550162848 } from "./1777550162848-MigrationName";
 import { MigrationName1777571961028 } from "./1777571961028-MigrationName";
+import { MigrationName1777629313843 } from "./1777629313843-MigrationName";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -593,4 +594,5 @@ export default [
   AddMonitorTemplate1777201966799,
   MigrationName1777550162848,
   MigrationName1777571961028,
+  MigrationName1777629313843,
 ];

package/Server/Infrastructure/Queue.ts

@@ -1,4 +1,4 @@
-import { ClusterKey } from "../EnvironmentConfig";
+import { QueueDashboardSecret } from "../EnvironmentConfig";
 import Dictionary from "../../Types/Dictionary";
 import { JSONObject } from "../../Types/JSON";
 import { Queue as BullQueue, Job, JobsOptions, RepeatableJob } from "bullmq";
@@ -153,7 +153,7 @@ export default class Queue {
 
   @CaptureSpan()
   public static getInspectorRoute(): string {
-    return "/worker/inspect/queue/:clusterKey";
+    return "/worker/inspect/queue/:dashboardSecret";
   }
 
   @CaptureSpan()
@@ -174,8 +174,8 @@ export default class Queue {
 
     serverAdapter.setBasePath(
       this.getInspectorRoute().replace(
-        "/:clusterKey",
-        "/" + ClusterKey.toString(),
+        "/:dashboardSecret",
+        "/" + QueueDashboardSecret,
       ),
     );
 

package/Server/Services/TelemetryAttributeService.ts

@@ -3,6 +3,7 @@ import TelemetryType from "../../Types/Telemetry/TelemetryType";
 import LogDatabaseService from "./LogService";
 import MetricDatabaseService from "./MetricService";
 import SpanDatabaseService from "./SpanService";
+import ExceptionInstanceService from "./ExceptionInstanceService";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
@@ -18,7 +19,12 @@ type TelemetrySource = {
   service: AnalyticsDatabaseService<any>;
   tableName: string;
   attributesColumn: string;
-  attributeKeysColumn: string;
+  /*
+   * Some tables (e.g. ExceptionInstance) don't have a separate
+   * attributeKeys array column — only the attributes map. Leave this
+   * undefined for those; the SQL falls back to mapKeys(attributes).
+   */
+  attributeKeysColumn?: string | undefined;
   timeColumn: string;
 };
 
@@ -62,6 +68,14 @@ export class TelemetryAttributeService {
           attributeKeysColumn: "attributeKeys",
           timeColumn: "startTime",
         };
+      case TelemetryType.Exception:
+        return {
+          service: ExceptionInstanceService,
+          tableName: ExceptionInstanceService.model.tableName,
+          attributesColumn: "attributes",
+          // ExceptionInstance has no attributeKeys column.
+          timeColumn: "time",
+        };
       default:
         return null;
     }
@@ -225,14 +239,21 @@ export class TelemetryAttributeService {
     projectId: ObjectID;
     tableName: string;
     attributesColumn: string;
-    attributeKeysColumn: string;
+    attributeKeysColumn?: string | undefined;
     timeColumn: string;
     metricName?: string | undefined;
   }): Statement {
     const lookbackStartDate: Date =
       TelemetryAttributeService.getLookbackStartDate();
 
-    const statement: Statement = SQL`
+    /*
+     * If the source has a denormalized attributeKeys array column, prefer it
+     * (avoids materializing every row's map). Otherwise fall back to
+     * mapKeys(attributes) — slower but works for tables that don't carry
+     * the precomputed array (e.g. ExceptionInstance).
+     */
+    const statement: Statement = data.attributeKeysColumn
+      ? SQL`
       WITH filtered AS (
         SELECT arrayJoin(
             if(
@@ -250,6 +271,19 @@ export class TelemetryAttributeService {
             NOT empty(${data.attributeKeysColumn}) OR
             NOT empty(${data.attributesColumn})
           )
+          AND ${data.timeColumn} >= ${{
+            type: TableColumnType.Date,
+            value: lookbackStartDate,
+          }}`
+      : SQL`
+      WITH filtered AS (
+        SELECT arrayJoin(mapKeys(${data.attributesColumn})) AS attribute
+        FROM ${data.tableName}
+        WHERE projectId = ${{
+          type: TableColumnType.ObjectID,
+          value: data.projectId,
+        }}
+          AND NOT empty(${data.attributesColumn})
           AND ${data.timeColumn} >= ${{
             type: TableColumnType.Date,
             value: lookbackStartDate,