@oneuptime/common 10.0.86 → 10.0.89

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/MetricAPI.ts

@@ -0,0 +1,149 @@
+import AggregateBy from "../../Types/BaseDatabase/AggregateBy";
+import AggregatedResult from "../../Types/BaseDatabase/AggregatedResult";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadRequestException from "../../Types/Exception/BadRequestException";
+import { JSONObject } from "../../Types/JSON";
+import JSONFunctions from "../../Types/JSONFunctions";
+import Metric from "../../Models/AnalyticsModels/Metric";
+import { MetricService } from "../Services/MetricService";
+import GlobalCache from "../Infrastructure/GlobalCache";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { ExpressRequest, ExpressResponse } from "../Utils/Express";
+import Response from "../Utils/Response";
+import CommonAPI from "./CommonAPI";
+import BaseAnalyticsAPI from "./BaseAnalyticsAPI";
+
+/*
+ * Aggregate cache TTL. Dashboards typically auto-refresh every 30s+, so
+ * an 8s window collapses bursts of identical requests (e.g. 12 widgets
+ * loading on the same page) onto a single ClickHouse query while still
+ * looking real-time to humans.
+ */
+const AGGREGATE_CACHE_NAMESPACE: string = "metric-aggregate";
+const AGGREGATE_CACHE_TTL_SECONDS: number = 8;
+
+export default class MetricAPI extends BaseAnalyticsAPI<Metric, MetricService> {
+  public constructor(service: MetricService) {
+    super(Metric, service);
+  }
+
+  /*
+   * Cached override of BaseAnalyticsAPI.getAggregate.
+   *
+   * Why a cache: each chart/value/gauge/table widget on a dashboard
+   * issues its own /aggregate call. With 10+ widgets and a small group
+   * of users hitting the same dashboard the underlying ClickHouse
+   * cluster sees the same heavy aggregation many times in close
+   * succession. Aggregations are read-only and pure (same input ->
+   * same output for the bucket interval), so a brief result cache is
+   * safe.
+   *
+   * Cache key: tenant project + the deserialized aggregateBy payload.
+   * We must include the project so cross-tenant collisions cannot
+   * leak data; we deliberately do NOT key on user id, because the
+   * service layer applies project-scoped read permissions and metric
+   * data is project-wide.
+   *
+   * Cache miss / Redis down: we fall through to the live query, so
+   * cache outages degrade to today's behavior, never error.
+   */
+  @CaptureSpan()
+  public override async getAggregate(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    await this.onBeforeList(req, res);
+
+    let aggregateBy: AggregateBy<Metric> | null = null;
+
+    if (req.body && req.body["aggregateBy"]) {
+      aggregateBy = JSONFunctions.deserialize(
+        req.body["aggregateBy"] as JSONObject,
+      ) as any;
+    }
+
+    if (!aggregateBy) {
+      throw new BadRequestException("AggregateBy is required");
+    }
+
+    const databaseProps: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    const projectId: string | undefined = databaseProps.tenantId?.toString();
+    const cacheKey: string | null = projectId
+      ? `${projectId}:${this.buildCacheKey(aggregateBy)}`
+      : null;
+
+    if (cacheKey) {
+      try {
+        const cached: JSONObject | null = await GlobalCache.getJSONObject(
+          AGGREGATE_CACHE_NAMESPACE,
+          cacheKey,
+        );
+        if (cached) {
+          return Response.sendJsonObjectResponse(req, res, cached);
+        }
+      } catch (err) {
+        // Cache fetch failed — fall through to a live query.
+        logger.debug("MetricAPI aggregate cache read failed");
+        logger.debug(err);
+      }
+    }
+
+    const aggregateResult: AggregatedResult = await this.service.aggregateBy({
+      ...aggregateBy,
+      props: databaseProps,
+    });
+
+    const responseBody: JSONObject = { ...(aggregateResult as any) };
+
+    if (cacheKey) {
+      try {
+        await GlobalCache.setJSON(
+          AGGREGATE_CACHE_NAMESPACE,
+          cacheKey,
+          responseBody,
+          { expiresInSeconds: AGGREGATE_CACHE_TTL_SECONDS },
+        );
+      } catch (err) {
+        logger.debug("MetricAPI aggregate cache write failed");
+        logger.debug(err);
+      }
+    }
+
+    return Response.sendJsonObjectResponse(req, res, responseBody);
+  }
+
+  private buildCacheKey(aggregateBy: AggregateBy<Metric>): string {
+    /*
+     * Stable serialization. Date instances are normalized to ISO so two
+     * logically-equal time windows hit the same cache slot, and we sort
+     * keys via JSON.stringify replacer to keep ordering deterministic
+     * across clients and across versions of V8.
+     */
+    return JSON.stringify(
+      aggregateBy,
+      (_key: string, value: unknown): unknown => {
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (
+          value &&
+          typeof value === "object" &&
+          !Array.isArray(value) &&
+          (value as Record<string, unknown>).constructor === Object
+        ) {
+          const sorted: Record<string, unknown> = {};
+          for (const k of Object.keys(
+            value as Record<string, unknown>,
+          ).sort()) {
+            sorted[k] = (value as Record<string, unknown>)[k];
+          }
+          return sorted;
+        }
+        return value;
+      },
+    );
+  }
+}

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/AnalyticsDatabaseService.ts

@@ -787,6 +787,27 @@ export default class AnalyticsDatabaseService<
     }}
         `);
 
+    /*
+     * Aggregation read-path settings.
+     *
+     * - optimize_aggregation_in_order: when GROUP BY is a prefix of the
+     *   sort key (we always group by a time bucket and the time column
+     *   is at the tail of every analytics primary key), ClickHouse can
+     *   stream rows in order and emit aggregates without an in-memory
+     *   sort, which is a large speedup on wide time ranges.
+     * - optimize_move_to_prewhere: PREWHERE is a default-on optimizer
+     *   pass; we set it explicitly so the behavior is independent of
+     *   server-side defaults.
+     * - max_threads=4: caps per-query parallelism so a single dashboard
+     *   load (which fans out to many aggregate calls) does not starve
+     *   other tenants on the cluster. Per-query latency is essentially
+     *   unchanged at 4 threads for the usual dashboard widget time
+     *   ranges, but cluster headroom is preserved under burst.
+     */
+    statement.append(
+      ` SETTINGS optimize_aggregation_in_order=1, optimize_move_to_prewhere=1, max_threads=4`,
+    );
+
     logger.debug(`${this.model.tableName} Aggregate Statement`, { tableName: this.model.tableName } as LogAttributes);
     logger.debug(statement, { tableName: this.model.tableName } as LogAttributes);