@oneuptime/common 10.4.14 → 10.4.16

package/Server/Services/MetricService.ts

@@ -4,12 +4,15 @@ import Metric from "../../Models/AnalyticsModels/Metric";
 import AggregateBy, {
   AggregateUtil,
 } from "../Types/AnalyticsDatabase/AggregateBy";
+import DeleteBy from "../Types/AnalyticsDatabase/DeleteBy";
+import Query from "../Types/AnalyticsDatabase/Query";
 import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
 import AggregationType, {
   getPercentileLevel,
   isPercentileAggregation,
 } from "../../Types/BaseDatabase/AggregationType";
 import AggregationInterval from "../../Types/BaseDatabase/AggregationInterval";
+import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
 import logger, { LogAttributes } from "../Utils/Logger";
 
@@ -18,6 +21,116 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     super({ modelType: Metric, database: clickhouseDatabase });
   }
 
+  /*
+   * Cascade deletes from `MetricItemV2` into the aggregating
+   * materialized-view target tables.
+   *
+   * `MetricItemAggMV1m` and `MetricBaselineHourly` are AggregatingMergeTree
+   * tables populated by attached MVs that only fire on inserts —
+   * `ALTER ... DELETE` against the source table does not roll back the
+   * previously-accumulated `sumState`/`countState` rows already in the MV
+   * tables. Without a matching DELETE on each MV, dashboard widgets that
+   * read from `MetricItemAggMV1m` keep counting and averaging metrics
+   * belonging to entities (incidents, alerts) the user has just deleted.
+   * See https://github.com/OneUptime/oneuptime/issues/2419.
+   *
+   * The cascade only runs when the caller scoped the delete by
+   * `serviceId`. Global time-based purges (TTL cleanup) are handled by
+   * each MV table's own `retentionDate TTL DELETE`, so cascading those
+   * would pointlessly scan the whole MV. The per-host MV
+   * (`MetricItemAggMV1mByHost`) is keyed by `hostIdentifier` rather than
+   * `serviceId`, so a service-scoped delete has nothing to remove there —
+   * skip it.
+   */
+  public override async deleteBy(deleteBy: DeleteBy<Metric>): Promise<void> {
+    await super.deleteBy(deleteBy);
+
+    const cascadeQuery: Query<Metric> | null = this.buildMVCascadeQuery(
+      deleteBy.query,
+    );
+    if (!cascadeQuery) {
+      return;
+    }
+
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+    const databaseName: string = this.database.getDatasourceOptions().database!;
+    const whereStatement: Statement =
+      this.statementGenerator.toWhereStatement(cascadeQuery);
+
+    const cascadeTargets: ReadonlyArray<AnalyticsTableName> = [
+      AnalyticsTableName.MetricItemAggMV1m,
+      AnalyticsTableName.MetricBaselineHourly,
+    ];
+
+    for (const tableName of cascadeTargets) {
+      try {
+        /*
+         * Lightweight delete — see toDeleteStatement() in
+         * AnalyticsDatabaseService for the rationale (avoids the
+         * ALTER mutations queue which is capped at 1000 per table).
+         */
+        const statement: Statement =
+          SQL`DELETE FROM ${databaseName}.${tableName} WHERE TRUE `.append(
+            whereStatement,
+          );
+        await this.execute(statement);
+      } catch (err) {
+        logger.error(
+          `Cascade delete into ${tableName} failed; dashboard widgets reading from this MV may temporarily show stale aggregated values for the deleted entity.`,
+        );
+        logger.error(err);
+      }
+    }
+  }
+
+  private buildMVCascadeQuery(query: Query<Metric>): Query<Metric> | null {
+    if (!query || typeof query !== "object") {
+      return null;
+    }
+
+    const queryRecord: Record<string, unknown> = query as unknown as Record<
+      string,
+      unknown
+    >;
+
+    /*
+     * Cascade only when the delete is scoped by serviceId. The MV sort
+     * key is (projectId, name, serviceId, bucketTime); without serviceId
+     * the DELETE would scan a huge swath of unrelated rows and risk
+     * removing data that belongs to other entities sharing the same
+     * project.
+     */
+    if (
+      queryRecord["serviceId"] === undefined ||
+      queryRecord["serviceId"] === null
+    ) {
+      return null;
+    }
+
+    /*
+     * Only project the keys the MV target tables actually expose.
+     * `time`, `attributes`, `serviceType`, and the metric-payload
+     * columns don't exist on the MV schema and would either fail
+     * where-statement generation or reference a missing column.
+     */
+    const allowedKeys: ReadonlyArray<string> = [
+      "projectId",
+      "name",
+      "serviceId",
+    ];
+    const out: Record<string, unknown> = {};
+    for (const key of allowedKeys) {
+      const value: unknown = queryRecord[key];
+      if (value !== undefined) {
+        out[key] = value;
+      }
+    }
+
+    return out as unknown as Query<Metric>;
+  }
+
   /**
    * Histogram-aware aggregation override.
    *

package/Server/Services/ProjectService.ts

@@ -103,6 +103,16 @@ export class ProjectService extends DatabaseService<Model> {
    */
   private requireSsoForLoginCache: InMemoryTTLCache<boolean> =
     new InMemoryTTLCache(10_000);
+  /*
+   * Caches the current billing plan per project. `getCurrentPlan` is hit
+   * by `CommonAPI.getDatabaseCommonInteractionProps` on every
+   * authenticated request when billing is enabled — without caching,
+   * that's one Postgres findOneById per API call to a billable project.
+   * Plans change rarely (subscription create / cancel / change), so a
+   * 60s staleness window is acceptable.
+   */
+  private currentPlanCache: InMemoryTTLCache<CurrentPlan> =
+    new InMemoryTTLCache(10_000);
 
   public constructor() {
     super(Model);
@@ -1492,6 +1502,12 @@ export class ProjectService extends DatabaseService<Model> {
       return { plan: null, isSubscriptionUnpaid: false };
     }
 
+    const cacheKey: string = projectId.toString();
+    const cached: CurrentPlan | undefined = this.currentPlanCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+
     const project: Model | null = await this.findOneById({
       id: projectId,
       select: {
@@ -1506,10 +1522,12 @@ export class ProjectService extends DatabaseService<Model> {
     });
 
     if (!project) {
+      // Don't cache "not found" — let the caller surface a fresh error.
       throw new BadDataException("Project ID is invalid");
     }
 
     if (!project.paymentProviderPlanId) {
+      // Don't cache "no plan" — the project may be mid-onboarding.
       throw new BadDataException("Project does not have any plans");
     }
 
@@ -1518,7 +1536,7 @@ export class ProjectService extends DatabaseService<Model> {
       getAllEnvVars(),
     );
 
-    return {
+    const result: CurrentPlan = {
       plan: plan,
       isSubscriptionUnpaid:
         !BillingService.isSubscriptionActive(
@@ -1528,6 +1546,8 @@ export class ProjectService extends DatabaseService<Model> {
           project.paymentProviderMeteredSubscriptionStatus!,
         ),
     };
+    this.currentPlanCache.set(cacheKey, result, 60_000);
+    return result;
   }
 
   @CaptureSpan()

package/Server/Utils/Response.ts

@@ -121,6 +121,7 @@ export default class Response {
     list: Array<BaseModel | AnalyticsDataModel>,
     count: PositiveNumber | number,
     modelType: { new (): BaseModel | AnalyticsDataModel },
+    options?: { hasMore?: boolean | undefined } | undefined,
   ): void {
     if (!(count instanceof PositiveNumber)) {
       count = new PositiveNumber(count);
@@ -144,7 +145,7 @@ export default class Response {
       );
     }
 
-    return this.sendJsonArrayResponse(req, res, jsonArray, count);
+    return this.sendJsonArrayResponse(req, res, jsonArray, count, options);
   }
 
   @CaptureSpan()
@@ -194,6 +195,7 @@ export default class Response {
     res: ExpressResponse,
     list: Array<JSONObject>,
     count: PositiveNumber,
+    options?: { hasMore?: boolean | undefined } | undefined,
   ): void {
     const oneUptimeRequest: OneUptimeRequest = req as OneUptimeRequest;
     const oneUptimeResponse: OneUptimeResponse = res as OneUptimeResponse;
@@ -203,6 +205,7 @@ export default class Response {
       count: new PositiveNumber(0),
       skip: new PositiveNumber(0),
       limit: new PositiveNumber(0),
+      hasMore: options?.hasMore,
     });
 
     if (!list) {

package/Server/Utils/UserPermission/UserPermission.ts

@@ -10,6 +10,22 @@ import PermissionNamespace from "../../Types/Permission/PermissionNamespace";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 
 export default class UserPermissionUtil {
+  /*
+   * Build the cache key for a (user, project) tenant-permission entry.
+   * The previous shape was `userId.toString() + projectId.toString()`
+   * with no separator — two distinct ObjectID pairs could in principle
+   * collide because plain concatenation has no boundary marker. Use a
+   * delimiter so the namespace is unambiguous, and route both the GET
+   * (here) and the SET (in `AccessTokenService.refreshUserTenant
+   * AccessPermission`) through this helper so they can't drift.
+   */
+  public static buildTenantPermissionCacheKey(
+    userId: ObjectID,
+    projectId: ObjectID,
+  ): string {
+    return `${userId.toString()}:${projectId.toString()}`;
+  }
+
   @CaptureSpan()
   public static async getUserTenantAccessPermissionFromCache(
     userId: ObjectID,
@@ -18,7 +34,7 @@ export default class UserPermissionUtil {
     const json: UserTenantAccessPermission | null =
       (await GlobalCache.getJSONObject(
         PermissionNamespace.ProjectPermission,
-        userId.toString() + projectId.toString(),
+        this.buildTenantPermissionCacheKey(userId, projectId),
       )) as UserTenantAccessPermission;
 
     if (json) {

package/Tests/Server/Services/AnalyticsDatabaseService.test.ts

@@ -357,8 +357,8 @@ describe("AnalyticsDatabaseService", () => {
       });
 
       expect(statement.query).toBe(
-        "ALTER TABLE {p0:Identifier}.{p1:Identifier}\n" +
-          "DELETE WHERE TRUE <where-statement>",
+        "DELETE FROM {p0:Identifier}.{p1:Identifier}\n" +
+          "WHERE TRUE <where-statement>",
       );
       expect(statement.query_params).toStrictEqual({
         p0: "oneuptime",

package/Types/API/HTTPResponse.ts

@@ -69,6 +69,19 @@ export default class HTTPResponse<
     this._skip = v;
   }
 
+  /*
+   * Optional. Set by analytics list endpoints that skip the expensive
+   * COUNT(*) and instead over-fetch by one row. When defined, `count`
+   * is only a lower bound — UI should drive next/prev from `hasMore`.
+   */
+  private _hasMore: boolean | undefined = undefined;
+  public get hasMore(): boolean | undefined {
+    return this._hasMore;
+  }
+  public set hasMore(v: boolean | undefined) {
+    this._hasMore = v;
+  }
+
   public constructor(
     statusCode: number,
     data: JSONObject | Array<JSONObject>,
@@ -86,6 +99,9 @@ export default class HTTPResponse<
       this.count = data["count"] as number;
       this.skip = data["skip"] as number;
       this.limit = data["limit"] as number;
+      if (Object.keys(data).includes("hasMore")) {
+        this.hasMore = data["hasMore"] as boolean;
+      }
       this.jsonData = JSONFunctions.deserializeArray(data["data"] as JSONArray);
     } else if (Array.isArray(data)) {
       this.jsonData = JSONFunctions.deserializeArray(data as JSONArray);

package/Types/BaseDatabase/ListResult.ts

@@ -9,4 +9,10 @@ export default interface ListResult<
   count: number;
   skip: number;
   limit: number;
+  /*
+   * Optional. When set, the analytics endpoint produced this result
+   * without a full COUNT(*) — `count` is only a lower bound. Drive
+   * pagination off `hasMore` rather than computing total pages.
+   */
+  hasMore?: boolean | undefined;
 }

package/Types/CustomField/CustomFieldType.ts

@@ -2,6 +2,8 @@ enum CustomFieldType {
   Text = "Text",
   Number = "Number",
   Boolean = "Boolean",
+  Dropdown = "Dropdown",
+  MultiSelectDropdown = "MultiSelectDropdown",
 }
 
 export default CustomFieldType;

package/Types/Date.ts

@@ -1554,7 +1554,15 @@ export default class OneUptimeDate {
           .toDate();
       }
 
-      return moment(trimmedDate).toDate();
+      /*
+       * moment.js throws on non-ISO formats like TLS cert dates ("Mar 31 00:00:00 2026 GMT").
+       * Fall back to native Date which handles this format correctly.
+       */
+      try {
+        return moment(trimmedDate).toDate();
+      } catch (_err: unknown) {
+        return new Date(trimmedDate);
+      }
     }
 
     if (

package/Types/ListData.ts

@@ -7,17 +7,27 @@ export default class ListData {
     count: PositiveNumber;
     skip: PositiveNumber;
     limit: PositiveNumber;
+    hasMore?: boolean | undefined;
   }) {
     this.data = obj.data;
     this.count = obj.count;
     this.skip = obj.skip;
     this.limit = obj.limit;
+    this.hasMore = obj.hasMore;
   }
 
   public data: JSONArray;
   public count: PositiveNumber;
   public skip: PositiveNumber;
   public limit: PositiveNumber;
+  /*
+   * When set, the response was produced without a full COUNT(*) — the
+   * server fetched LIMIT+1 rows and only knows whether at least one
+   * more page exists. `count` is still emitted as a lower-bound so
+   * older clients keep rendering, but UI that wants accurate "X of Y"
+   * should switch to `hasMore`-based pagination.
+   */
+  public hasMore?: boolean | undefined;
 
   public toJSON(): JSONObject {
     const json: JSONObject = {
@@ -27,6 +37,10 @@ export default class ListData {
       limit: this.limit.toNumber(),
     };
 
+    if (this.hasMore !== undefined) {
+      json["hasMore"] = this.hasMore;
+    }
+
     return json;
   }
 }

package/Types/Monitor/DnsMonitor/DnsMonitorResponse.ts

@@ -1,3 +1,4 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
 import DnsRecordType from "./DnsRecordType";
 
 export interface DnsRecordResponse {
@@ -13,4 +14,6 @@ export default interface DnsMonitorResponse {
   records: Array<DnsRecordResponse>;
   isDnssecValid?: boolean | undefined;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/DnssecMonitor/DnssecMonitorResponse.ts

@@ -1,3 +1,5 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+
 export interface DnssecKeyRecord {
   flags: number;
   algorithm: number;
@@ -66,4 +68,7 @@ export default interface DnssecMonitorResponse {
 
   // Overall chain validity (DNSKEY exists, DS exists, RRSIG valid, AD across resolvers)
   isChainValid: boolean;
+
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/DomainMonitor/DomainMonitorResponse.ts

@@ -1,3 +1,5 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+
 export default interface DomainMonitorResponse {
   isOnline: boolean;
   responseTimeInMs: number;
@@ -12,4 +14,6 @@ export default interface DomainMonitorResponse {
   dnssec?: string | undefined;
   domainStatus?: Array<string> | undefined;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse.ts

@@ -1,3 +1,5 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+
 export interface ExternalStatusPageComponentStatus {
   name: string;
   status: string;
@@ -13,4 +15,6 @@ export default interface ExternalStatusPageMonitorResponse {
   failureCause: string;
   rawBody?: string | undefined;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/SnmpMonitor/SnmpMonitorResponse.ts

@@ -1,3 +1,4 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
 import SnmpDataType from "./SnmpDataType";
 
 export interface SnmpOidResponse {
@@ -13,4 +14,6 @@ export default interface SnmpMonitorResponse {
   failureCause: string;
   oidResponses: Array<SnmpOidResponse>;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Probe/ProbeAttempt.ts

@@ -0,0 +1,9 @@
+export default interface ProbeAttempt {
+  attemptNumber: number;
+  attemptedAt: Date;
+  responseReceivedAt: Date;
+  responseTimeInMs?: number | undefined;
+  responseCode?: number | undefined;
+  isOnline: boolean;
+  failureCause?: string | undefined;
+}

package/Types/Probe/ProbeMonitorResponse.ts

@@ -14,6 +14,7 @@ import ExternalStatusPageMonitorResponse from "../Monitor/ExternalStatusPageMoni
 import MonitorEvaluationSummary from "../Monitor/MonitorEvaluationSummary";
 import ObjectID from "../ObjectID";
 import Port from "../Port";
+import ProbeAttempt from "./ProbeAttempt";
 import RequestFailedDetails from "./RequestFailedDetails";
 
 export default interface ProbeMonitorResponse {
@@ -42,4 +43,6 @@ export default interface ProbeMonitorResponse {
   isTimeout?: boolean | undefined;
   ingestedAt?: Date | undefined;
   evaluationSummary?: MonitorEvaluationSummary | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }