@oneuptime/common 10.4.13 → 10.4.15

package/Models/DatabaseModels/StatusPageCustomField.ts

@@ -244,6 +244,43 @@ export default class StatusPageCustomField extends BaseModel {
   })
   public customFieldType?: CustomFieldType = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateStatusPageCustomField,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.StatusPageAdmin,
+      Permission.StatusPageMember,
+      Permission.StatusPageViewer,
+      Permission.ReadStatusPageCustomField,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditStatusPageCustomField,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Dropdown Options",
+    description:
+      "Options for the dropdown field, one per line. Only used when Custom Field Type is Dropdown.",
+    example: "Option 1\nOption 2\nOption 3",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public dropdownOptions?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/StatusPageSubscriber.ts

@@ -94,6 +94,8 @@ import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 @Entity({
   name: "StatusPageSubscriber",
 })
+@Index(["statusPageId", "subscriberEmail"]) // Dedupe lookup on email subscribe
+@Index(["statusPageId", "subscriberPhone"]) // Dedupe lookup on phone subscribe
 export default class StatusPageSubscriber extends BaseModel {
   @ColumnAccessControl({
     create: [

package/Models/DatabaseModels/TableView.ts

@@ -22,6 +22,7 @@ import Query from "../../Types/BaseDatabase/Query";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Sort from "../../Types/BaseDatabase/Sort";
 import AnalyticsBaseModel from "../AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import { JSONObject } from "../../Types/JSON";
 
 @TableBillingAccessControl({
   create: PlanType.Growth,
@@ -515,4 +516,43 @@ export default class TableView extends BaseModel {
     default: 10,
   })
   public itemsOnPage?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTableView,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadTableView,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTableView,
+    ],
+  })
+  @TableColumn({
+    title: "Facets",
+    required: false,
+    unique: false,
+    type: TableColumnType.JSON,
+    canReadOnRelationQuery: true,
+    description:
+      "Facet selections (owner, labels, status, etc.) for this table view",
+    example: '{"selectedOwnerKeys": ["user:abc"], "facetSelections": {}}',
+  })
+  @Column({
+    type: ColumnType.JSON,
+    unique: false,
+    nullable: true,
+  })
+  public facets?: JSONObject = undefined;
 }

package/Models/DatabaseModels/TeamMemberCustomField.ts

@@ -248,6 +248,43 @@ export default class TeamMemberCustomField extends BaseModel {
   })
   public customFieldType?: CustomFieldType = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTeamMemberCustomField,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadTeamMemberCustomField,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTeamMemberCustomField,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Dropdown Options",
+    description:
+      "Options for the dropdown field, one per line. Only used when Custom Field Type is Dropdown.",
+    example: "Option 1\nOption 2\nOption 3",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public dropdownOptions?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/TelemetryException.ts

@@ -62,6 +62,7 @@ import Service from "./Service";
 @Entity({
   name: "TelemetryException",
 })
+@Index(["projectId", "isResolved", "isArchived"]) // Exceptions dashboard counts/filters
 export default class TelemetryException extends DatabaseBaseModel {
   @ColumnAccessControl({
     create: [
@@ -1096,6 +1097,7 @@ export default class TelemetryException extends DatabaseBaseModel {
       Permission.EditTelemetryException,
     ],
   })
+  @Index()
   @TableColumn({
     title: "Occurances",
     description: "Number of times this exception has occurred",

package/Models/DatabaseModels/UserOnCallLog.ts

@@ -536,6 +536,7 @@ export default class UserOnCallLog extends BaseModel {
     read: [Permission.CurrentUser],
     update: [],
   })
+  @Index()
   @TableColumn({
     required: true,
     type: TableColumnType.ShortText,

package/Models/DatabaseModels/WorkflowLog.ts

@@ -60,6 +60,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
   icon: IconProp.Logs,
   tableDescription: "Logs of the workflows executed",
 })
+@Index(["workflowStatus", "createdAt"]) // Worker sweep for scheduled/timed-out runs
 export default class WorkflowLog extends BaseModel {
   @ColumnAccessControl({
     create: [],

package/Server/API/BaseAnalyticsAPI.ts

@@ -29,6 +29,22 @@ import { UserPermission } from "../../Types/Permission";
 import PositiveNumber from "../../Types/PositiveNumber";
 import AggregatedResult from "../../Types/BaseDatabase/AggregatedResult";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import GlobalCache from "../Infrastructure/GlobalCache";
+import logger from "../Utils/Logger";
+
+/*
+ * 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.
+ *
+ * Project-scoped only: analytics data is project-wide and the
+ * service layer enforces project-scoped read permissions, so
+ * caching across users within the same project is safe. Endpoints
+ * with row-level access scoping should override `getAggregate` to
+ * skip the cache (or shape the key to include the access scope).
+ */
+const ANALYTICS_AGGREGATE_CACHE_TTL_SECONDS: number = 8;
 
 export default class BaseAnalyticsAPI<
   TAnalyticsDataModel extends AnalyticsDataModel,
@@ -268,29 +284,46 @@ export default class BaseAnalyticsAPI<
     const databaseProps: DatabaseCommonInteractionProps =
       await CommonAPI.getDatabaseCommonInteractionProps(req);
 
-    const [list, count] = await Promise.all([
-      this.service.findBy({
-        query,
-        select,
-        skip: skip,
-        limit: limit,
-        sort: sort,
-        groupBy: groupBy,
-        props: databaseProps,
-      }),
-      this.service.countBy({
-        query,
-        groupBy: groupBy,
-        props: databaseProps,
-      }),
-    ]);
+    /*
+     * Skip the parallel countBy on analytics tables. countBy on Log /
+     * Span / Metric over wide time ranges scans every matching block
+     * (no LIMIT) and routinely dominates list-endpoint latency under
+     * heavy ingest. Instead we over-fetch by one row and derive
+     * `hasMore` from whether the extra row showed up. `count` is
+     * emitted as a lower bound (`skip + data.length + hasMore`) so
+     * older clients that read `count` keep rendering something
+     * sensible while newer clients use `hasMore` for prev/next.
+     */
+    const overfetchLimit: PositiveNumber = new PositiveNumber(
+      limit.toNumber() + 1,
+    );
+
+    const list: Array<AnalyticsDataModel> = await this.service.findBy({
+      query,
+      select,
+      skip: skip,
+      limit: overfetchLimit,
+      sort: sort,
+      groupBy: groupBy,
+      props: databaseProps,
+    });
+
+    const hasMore: boolean = list.length > limit.toNumber();
+    if (hasMore) {
+      list.length = limit.toNumber();
+    }
+
+    const lowerBoundCount: PositiveNumber = new PositiveNumber(
+      skip.toNumber() + list.length + (hasMore ? 1 : 0),
+    );
 
     return Response.sendEntityArrayResponse(
       req,
       res,
       list,
-      count,
+      lowerBoundCount,
       this.entityType,
+      { hasMore },
     );
   }
 
@@ -327,14 +360,89 @@ export default class BaseAnalyticsAPI<
     const databaseProps: DatabaseCommonInteractionProps =
       await CommonAPI.getDatabaseCommonInteractionProps(req);
 
+    /*
+     * Short-lived project-scoped cache. A dashboard refresh fires
+     * one /aggregate call per widget — typically 10+ identical or
+     * near-identical aggregations against the same time window
+     * inside a few hundred milliseconds. Cache the result for 8s
+     * so the underlying ClickHouse aggregation runs once per
+     * burst. On cache outage (Redis down, parse error, …) we fall
+     * through to a live query so behavior degrades to today's.
+     */
+    const projectId: string | undefined = databaseProps.tenantId?.toString();
+    const cacheNamespace: string = `${this.getEntityName()}-aggregate`;
+    const cacheKey: string | null = projectId
+      ? `${projectId}:${this.buildAggregateCacheKey(aggregateBy)}`
+      : null;
+
+    if (cacheKey) {
+      try {
+        const cached: JSONObject | null = await GlobalCache.getJSONObject(
+          cacheNamespace,
+          cacheKey,
+        );
+        if (cached) {
+          return Response.sendJsonObjectResponse(req, res, cached);
+        }
+      } catch (err) {
+        logger.debug(`${cacheNamespace} cache read failed`);
+        logger.debug(err);
+      }
+    }
+
     const aggregateResult: AggregatedResult = await this.service.aggregateBy({
       ...aggregateBy,
       props: databaseProps,
     });
 
-    return Response.sendJsonObjectResponse(req, res, {
-      ...(aggregateResult as any),
-    });
+    const responseBody: JSONObject = { ...(aggregateResult as any) };
+
+    if (cacheKey) {
+      try {
+        await GlobalCache.setJSON(cacheNamespace, cacheKey, responseBody, {
+          expiresInSeconds: ANALYTICS_AGGREGATE_CACHE_TTL_SECONDS,
+        });
+      } catch (err) {
+        logger.debug(`${cacheNamespace} cache write failed`);
+        logger.debug(err);
+      }
+    }
+
+    return Response.sendJsonObjectResponse(req, res, responseBody);
+  }
+
+  /*
+   * Stable serialization for the aggregate cache key. Date instances
+   * are normalized to ISO so two logically-equal time windows hit
+   * the same cache slot, and we sort object keys so the ordering is
+   * deterministic across clients and across V8 versions.
+   */
+  protected buildAggregateCacheKey(
+    aggregateBy: AggregateBy<AnalyticsDataModel>,
+  ): string {
+    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;
+      },
+    );
   }
 
   @CaptureSpan()

package/Server/API/MetricAPI.ts

@@ -1,149 +1,16 @@
-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.
+ * Metric CRUD + aggregate endpoints. The 8-second project-scoped
+ * aggregate cache that used to live here has been promoted to
+ * `BaseAnalyticsAPI.getAggregate` so Log/Span/AuditLog/etc. benefit
+ * from the same dashboard-widget-burst collapse without duplicating
+ * the wrapper on every analytics API.
  */
-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/ProjectAPI.ts

@@ -5,6 +5,7 @@ import ProjectService, {
 } from "../Services/ProjectService";
 import ResellerService from "../Services/ResellerService";
 import TeamMemberService from "../Services/TeamMemberService";
+import QueryHelper from "../Types/Database/QueryHelper";
 import Select from "../Types/Database/Select";
 import {
   ExpressRequest,
@@ -223,25 +224,61 @@ export default class ProjectAPI extends BaseAPI<Project, ProjectServiceType> {
             }
           }
 
-          // get reseller for each project.
+          /*
+           * Batch-fetch resellers for every project in one query instead of
+           * one findOneById per project.
+           */
+          const resellerIds: Array<ObjectID> = [];
+          const seenResellerIds: Set<string> = new Set<string>();
           for (const project of projects) {
-            if (project.resellerId) {
-              const reseller: Reseller | null =
-                await ResellerService.findOneById({
-                  id: project.resellerId,
-                  select: {
-                    enableTelemetryFeatures: true,
-                  },
-                  props: {
-                    isRoot: true,
-                  },
-                });
+            if (
+              project.resellerId &&
+              !seenResellerIds.has(project.resellerId.toString())
+            ) {
+              seenResellerIds.add(project.resellerId.toString());
+              resellerIds.push(project.resellerId);
+            }
+          }
 
-              if (!reseller) {
-                continue;
+          if (resellerIds.length > 0) {
+            const resellers: Array<Reseller> = await ResellerService.findBy({
+              query: {
+                _id: QueryHelper.any(
+                  resellerIds.map((id: ObjectID) => {
+                    return id.toString();
+                  }),
+                ),
+              },
+              select: {
+                _id: true,
+                enableTelemetryFeatures: true,
+              },
+              limit: LIMIT_PER_PROJECT,
+              skip: 0,
+              props: {
+                isRoot: true,
+              },
+            });
+
+            const resellersById: Map<string, Reseller> = new Map<
+              string,
+              Reseller
+            >();
+            for (const reseller of resellers) {
+              if (reseller._id) {
+                resellersById.set(reseller._id.toString(), reseller);
               }
+            }
 
-              project.reseller = reseller;
+            for (const project of projects) {
+              if (project.resellerId) {
+                const reseller: Reseller | undefined = resellersById.get(
+                  project.resellerId.toString(),
+                );
+                if (reseller) {
+                  project.reseller = reseller;
+                }
+              }
             }
           }