@oneuptime/common 14.0.12 → 14.0.13

package/Server/Services/AlertStateService.ts

@@ -1,15 +1,15 @@
-import logger from "../Utils/Logger";
 import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
-import QueryHelper from "../Types/Database/QueryHelper";
 import UpdateBy from "../Types/Database/UpdateBy";
 import DatabaseService from "./DatabaseService";
+import StateOrderGuard from "../Utils/Database/StateOrderGuard";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
+import { STATE_LISTS, StateListType } from "../../Utils/StateOrder";
 import AlertState from "../../Models/DatabaseModels/AlertState";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -18,23 +18,21 @@ export class Service extends DatabaseService<AlertState> {
     super(AlertState);
   }
 
+  /*
+   * A new state with no place goes just above the resolved state, and a signed-in
+   * create that would put the built-in states out of order is refused
+   * (Common/Server/Utils/Database/StateOrderGuard). Where it ends up in the
+   * list is then kept by DatabaseService (@ListOrderColumn).
+   */
   @CaptureSpan()
   protected override async onBeforeCreate(
     createBy: CreateBy<AlertState>,
   ): Promise<OnCreate<AlertState>> {
-    if (!createBy.data.order) {
-      throw new BadDataException("Alert State order is required");
-    }
-
-    if (!createBy.data.projectId) {
-      throw new BadDataException("Alert State projectId is required");
-    }
-
-    await this.rearrangeOrder(
-      createBy.data.order,
-      createBy.data.projectId,
-      true,
-    );
+    await StateOrderGuard.beforeCreate({
+      service: this,
+      definition: STATE_LISTS[StateListType.AlertState],
+      createBy: createBy,
+    });
 
     return {
       createBy: createBy,
@@ -52,123 +50,34 @@ export class Service extends DatabaseService<AlertState> {
       );
     }
 
-    let alertState: AlertState | null = null;
-
-    if (!deleteBy.props.isRoot) {
-      alertState = await this.findOneBy({
-        query: deleteBy.query,
-        props: {
-          isRoot: true,
-        },
-        select: {
-          order: true,
-          projectId: true,
-        },
-      });
-    }
+    // A project always keeps a created, an acknowledged and a resolved state.
+    await StateOrderGuard.beforeDelete({
+      service: this,
+      definition: STATE_LISTS[StateListType.AlertState],
+      deleteBy: deleteBy,
+    });
 
     return {
       deleteBy,
-      carryForward: alertState,
-    };
-  }
-
-  @CaptureSpan()
-  protected override async onDeleteSuccess(
-    onDelete: OnDelete<AlertState>,
-    _itemIdsBeforeDelete: ObjectID[],
-  ): Promise<OnDelete<AlertState>> {
-    const deleteBy: DeleteBy<AlertState> = onDelete.deleteBy;
-    const alertState: AlertState | null = onDelete.carryForward;
-
-    if (!deleteBy.props.isRoot && alertState) {
-      if (alertState && alertState.order && alertState.projectId) {
-        await this.rearrangeOrder(
-          alertState.order,
-          alertState.projectId,
-          false,
-        );
-      }
-    }
-
-    return {
-      deleteBy: deleteBy,
       carryForward: null,
     };
   }
 
+  /*
+   * A state can be moved - dragged on the settings page, or given another
+   * number through the API - as long as the created, acknowledged and resolved states keep their order.
+   */
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<AlertState>,
   ): Promise<OnUpdate<AlertState>> {
-    if (updateBy.data.order && !updateBy.props.isRoot) {
-      throw new BadDataException(
-        "Alert State order should not be updated. Delete this alert state and create a new state with the right order.",
-      );
-    }
-
-    return { updateBy, carryForward: null };
-  }
-
-  private async rearrangeOrder(
-    currentOrder: number,
-    projectId: ObjectID,
-    increaseOrder: boolean = true,
-  ): Promise<void> {
-    // get alert with this order.
-    const alertStates: Array<AlertState> = await this.findBy({
-      query: {
-        order: QueryHelper.greaterThanEqualTo(currentOrder),
-        projectId: projectId,
-      },
-      limit: LIMIT_MAX,
-      skip: 0,
-      props: {
-        isRoot: true,
-      },
-      select: {
-        _id: true,
-        order: true,
-      },
-      sort: {
-        order: SortOrder.Ascending,
-      },
+    await StateOrderGuard.beforeUpdate({
+      service: this,
+      definition: STATE_LISTS[StateListType.AlertState],
+      updateBy: updateBy,
     });
 
-    let newOrder: number = currentOrder;
-
-    for (const alertState of alertStates) {
-      if (increaseOrder) {
-        newOrder = alertState.order! + 1;
-      } else {
-        newOrder = alertState.order! - 1;
-      }
-
-      /*
-       * Concurrent deletes (e.g. Terraform destroying several items in
-       * parallel) can soft-delete a row between the findBy above and
-       * this update; save() would then INSERT with a null projectId and
-       * fail the whole delete with a 500. A row that vanished
-       * mid-rearrange needs no repositioning - skip it.
-       */
-      try {
-        await this.updateOneBy({
-          query: {
-            _id: alertState._id!,
-          },
-          data: {
-            order: newOrder,
-          },
-          props: {
-            isRoot: true,
-          },
-        });
-      } catch (err) {
-        logger.warn(
-          `rearrange: skipping row (likely deleted concurrently): ${err}`,
-        );
-      }
-    }
+    return { updateBy, carryForward: null };
   }
 
   @CaptureSpan()

package/Server/Services/AnalyticsDatabaseService.ts

@@ -62,6 +62,8 @@ import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import Exception from "../../Types/Exception/Exception";
 import ExceptionCode from "../../Types/Exception/ExceptionCode";
+import ServerException from "../../Types/Exception/ServerException";
+import TimeoutException from "../../Types/Exception/TimeoutException";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
@@ -212,6 +214,13 @@ export function shouldWaitForAsyncInsert(): boolean {
   return raw === "true" || raw === "1";
 }
 
+/*
+ * How long a count may run. Below the ClickHouse client's 58s
+ * request_timeout, so the server answers (or refuses) before the client
+ * gives up on it.
+ */
+const COUNT_MAX_EXECUTION_TIME_IN_SECONDS: number = 45;
+
 export default class AnalyticsDatabaseService<
   TBaseModel extends AnalyticsBaseModel,
 > extends BaseService {
@@ -419,6 +428,17 @@ export default class AnalyticsDatabaseService<
   @CaptureSpan()
   public async countBy(countBy: CountBy<TBaseModel>): Promise<PositiveNumber> {
     try {
+      /*
+       * The same rewrite a findBy gets, and before the permission check for
+       * the same reason: it turns client-only keys (a telemetry explorer's
+       * `resourceFilters`) into the ones the statement compiler reads, and
+       * the check refuses any key that is not a column. Without it, counting
+       * the rows of a list narrowed by a resource facet failed outright.
+       */
+      if (!countBy.props?.ignoreHooks) {
+        countBy = await this.onBeforeCount(countBy);
+      }
+
       const checkReadPermissionType: CheckReadPermissionType<TBaseModel> =
         await ModelPermission.checkReadPermission(
           this.modelType,
@@ -431,8 +451,13 @@ export default class AnalyticsDatabaseService<
 
       const countStatement: Statement = this.toCountStatement(countBy);
 
-      const dbResult: ResultSet<"JSON"> =
-        await this.executeQuery(countStatement);
+      let dbResult: ResultSet<"JSON">;
+
+      try {
+        dbResult = await this.executeQuery(countStatement);
+      } catch (error) {
+        throw this.toCountException(countBy, error);
+      }
 
       logger.debug(`${this.model.tableName} Count Statement executed`, {
         tableName: this.model.tableName,
@@ -442,6 +467,7 @@ export default class AnalyticsDatabaseService<
       } as LogAttributes);
 
       let countPositive: PositiveNumber = new PositiveNumber(0);
+      let hasCount: boolean = false;
 
       try {
         const resultInJSON: ResponseJSON<JSONObject> =
@@ -464,6 +490,7 @@ export default class AnalyticsDatabaseService<
 
         if (typeof rawCount === "string" || typeof rawCount === "number") {
           countPositive = new PositiveNumber(rawCount);
+          hasCount = true;
         }
       } catch {
         /*
@@ -471,11 +498,23 @@ export default class AnalyticsDatabaseService<
          * ClickHouse may return a truncated response for count() queries
          * (the aggregation has no partial row to emit). Treat this as
          * "count unavailable" rather than a fatal error — the list query
-         * itself still succeeds.
+         * itself still succeeds. An exact count fails below instead.
          */
-        logger.warn(
-          `${this.model.tableName} count query returned unparseable response, defaulting to 0`,
-          { tableName: this.model.tableName } as LogAttributes,
+        if (!countBy.exact) {
+          logger.warn(
+            `${this.model.tableName} count query returned unparseable response, defaulting to 0`,
+            { tableName: this.model.tableName } as LogAttributes,
+          );
+        }
+      }
+
+      /*
+       * A 0 that stands for "no answer" is fine for a threshold, and wrong
+       * for a total a person reads: "0 spans" over a list of spans.
+       */
+      if (countBy.exact && !hasCount) {
+        throw new ServerException(
+          `The ${this.model.singularName.toLowerCase()} count came back without a number.`,
         );
       }
 
@@ -1200,6 +1239,58 @@ export default class AnalyticsDatabaseService<
     return Promise.resolve({ findBy, carryForward: null });
   }
 
+  /*
+   * A place holder method used for overriding. A service whose onBeforeFind
+   * rewrites the query must rewrite a count's query the same way, or the
+   * count describes different rows than the list it is shown beside.
+   */
+  protected async onBeforeCount(
+    countBy: CountBy<TBaseModel>,
+  ): Promise<CountBy<TBaseModel>> {
+    return Promise.resolve(countBy);
+  }
+
+  /*
+   * Whether ClickHouse refused to finish a query in the time it was given:
+   * TIMEOUT_EXCEEDED (159) once max_execution_time passes with
+   * timeout_overflow_mode 'throw', or TOO_SLOW (160) when the server
+   * estimates up front that it would.
+   */
+  public static isQueryTimeoutError(error: unknown): boolean {
+    if (!error || typeof error !== "object") {
+      return false;
+    }
+
+    const code: unknown = (error as { code?: unknown }).code;
+    const type: unknown = (error as { type?: unknown }).type;
+
+    return (
+      code === "159" ||
+      code === "160" ||
+      type === "TIMEOUT_EXCEEDED" ||
+      type === "TOO_SLOW"
+    );
+  }
+
+  /*
+   * What a failed count query is rethrown as. An exact count that ran out of
+   * time says so, and says what to do about it, rather than surfacing as an
+   * unexplained database error: the explorers that show the total tell the
+   * reader to narrow the window.
+   */
+  private toCountException(
+    countBy: CountBy<TBaseModel>,
+    error: unknown,
+  ): unknown {
+    if (countBy.exact && AnalyticsDatabaseService.isQueryTimeoutError(error)) {
+      return new TimeoutException(
+        `Counting every matching ${this.model.singularName.toLowerCase()} took longer than ${COUNT_MAX_EXECUTION_TIME_IN_SECONDS} seconds. Narrow the time range or add a filter to get an exact total.`,
+      );
+    }
+
+    return error;
+  }
+
   /**
    * Read-side retention filter. TTL deletes rows by `retentionDate`, and
    * ClickHouse applies it only when it merges: on a table with
@@ -1277,12 +1368,14 @@ export default class AnalyticsDatabaseService<
      * can scan billions of rows; without a cap the query runs until the
      * HTTP client disconnects, wasting ClickHouse resources. With 'break'
      * mode ClickHouse returns a partial (lower-bound) count rather than
-     * throwing, which is acceptable for pagination display.
+     * throwing, which is acceptable for a threshold. It is not for an exact
+     * count: a partial count printed as a total is a wrong total, so that
+     * one fails instead (see countBy).
      */
     statement.append(
       getQuerySettings({
-        maxExecutionTimeInSeconds: 45,
-        timeoutOverflowMode: "break",
+        maxExecutionTimeInSeconds: COUNT_MAX_EXECUTION_TIME_IN_SECONDS,
+        timeoutOverflowMode: countBy.exact ? "throw" : "break",
       }),
     );