@oneuptime/common 11.6.0 → 11.6.2

package/Server/Services/SloHistoryService.ts

@@ -0,0 +1,101 @@
+import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
+import ClickhouseDatabase from "../Infrastructure/ClickhouseDatabase";
+import SloHistory from "../../Models/AnalyticsModels/SloHistory";
+import OneUptimeDate from "../../Types/Date";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+
+/**
+ * One time-bucketed SLO measurement to persist. `metricName` is one of
+ * the SloHistory series names ("sli.percent",
+ * "error.budget.remaining.percent", "burn.rate", "good.count",
+ * "total.count").
+ */
+export interface SloHistoryRow {
+  projectId: ObjectID;
+  sloId: ObjectID;
+  metricName: string;
+  bucketStart: Date;
+  value: number;
+}
+
+/**
+ * Service for the `SloHistory` ReplacingMergeTree table.
+ *
+ * Writes come from the SLO evaluation worker via
+ * {@link insertHistoryRows}. History is POINT-IN-TIME: each evaluation
+ * writes exactly one minute-floored bucket per series, once, with the
+ * numbers as computed at that moment. Retroactive edits to the
+ * underlying MonitorStatusTimeline are NOT restated into already-written
+ * buckets — the SLO overview page always recomputes its current numbers
+ * from Postgres and therefore self-heals, while the charts stay a
+ * historical record of what was reported at the time.
+ *
+ * ReplacingMergeTree + the per-batch `version` stamp (unix millis)
+ * therefore guard exactly one thing: a rare double write of the same
+ * (projectId, sloId, metricName, bucketStart) identity — a retried job,
+ * or two runs landing in the same minute — collapses to the highest
+ * version at merge time instead of double-counting. Merges are
+ * asynchronous, so a naive reader can transiently see both rows; that is
+ * why the chart layer reads through `/aggregate` (its GROUP BY on the
+ * bucketed timestamp collapses duplicates) and why a raw reader would
+ * need `argMax(value, version) ... GROUP BY <identity>` (MutableMetric
+ * precedent).
+ *
+ * Possible future work: restating a trailing window of buckets on every
+ * run so retroactive timeline edits propagate into history. The version
+ * machinery already supports it (a later run's rewrite carries a
+ * strictly larger version and wins), but nothing writes those rewrites
+ * today.
+ */
+export class SloHistoryService extends AnalyticsDatabaseService<SloHistory> {
+  public constructor(clickhouseDatabase?: ClickhouseDatabase | undefined) {
+    super({ modelType: SloHistory, database: clickhouseDatabase });
+  }
+
+  /*
+   * Insert history rows. All rows in one call share a single `version`
+   * stamp (unix millis at write time), so if the same bucket is ever
+   * written twice — a retried job, or a re-run landing in the same
+   * minute — the later write carries a strictly larger version and wins
+   * the ReplacingMergeTree dedupe instead of double-counting. Rows with
+   * a missing/non-finite value are skipped (same discipline as
+   * MonitorMetricUtil's metric-row builder).
+   */
+  public async insertHistoryRows(rows: Array<SloHistoryRow>): Promise<void> {
+    if (!rows || rows.length === 0) {
+      return;
+    }
+
+    const now: Date = OneUptimeDate.getCurrentDate();
+    const createdAt: string = OneUptimeDate.toClickhouseDateTime(now);
+    const version: number = now.getTime();
+
+    const jsonRows: Array<JSONObject> = [];
+
+    for (const row of rows) {
+      if (typeof row.value !== "number" || !isFinite(row.value)) {
+        continue;
+      }
+
+      jsonRows.push({
+        _id: ObjectID.generateTimeOrdered().toString(),
+        createdAt: createdAt,
+        projectId: row.projectId.toString(),
+        sloId: row.sloId.toString(),
+        metricName: row.metricName,
+        bucketStart: OneUptimeDate.toClickhouseDateTime(row.bucketStart),
+        value: row.value,
+        version: version,
+      } as JSONObject);
+    }
+
+    if (jsonRows.length === 0) {
+      return;
+    }
+
+    await this.insertJsonRows(jsonRows);
+  }
+}
+
+export default new SloHistoryService();

package/Server/Services/UserNotificationSettingService.ts

@@ -581,6 +581,24 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     await this.addAlertEpisodeNotificationSettings(userId, projectId);
     await this.addIncidentEpisodeNotificationSettings(userId, projectId);
     await this.addScheduledMaintenanceNotificationSettings(userId, projectId);
+    await this.addSloNotificationSettings(userId, projectId);
+  }
+
+  private async addSloNotificationSettings(
+    userId: ObjectID,
+    projectId: ObjectID,
+  ): Promise<void> {
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_SLO_OWNER_STATUS_CHANGE_NOTIFICATION,
+    );
+
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_SLO_OWNER_ADDED_NOTIFICATION,
+    );
   }
 
   private async addScheduledMaintenanceNotificationSettings(
@@ -761,6 +779,25 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     );
   }
 
+  /*
+   * Ensures a UserNotificationSetting row exists for the given user, project
+   * and event type. If no row exists, a default-enabled (email) row is
+   * created. This is useful for event types added after a user joined a
+   * project, since sendUserNotification no-ops when no row exists.
+   */
+  @CaptureSpan()
+  public async ensureSettingExistsForUser(data: {
+    userId: ObjectID;
+    projectId: ObjectID;
+    eventType: NotificationSettingEventType;
+  }): Promise<void> {
+    await this.addNotificationSettingIfNotExists(
+      data.userId,
+      data.projectId,
+      data.eventType,
+    );
+  }
+
   private async addNotificationSettingIfNotExists(
     userId: ObjectID,
     projectId: ObjectID,

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -82,6 +82,15 @@ export class AggregateUtil {
    *   - normal interval → buildBucketTimestampExpression(...) `as col`
    *   - Total           → `min(col) as col` (one row per group; the
    *     earliest sample timestamp in the window is the bucket label)
+   *
+   * IMPORTANT: because the alias shadows the real column, ClickHouse
+   * substitutes it into any same-level unqualified `WHERE col ...`
+   * reference — for Total that injects an aggregate into WHERE
+   * (ILLEGAL_AGGREGATION), and for bucketed intervals it silently
+   * filters on the truncated bucket. Every builder that embeds this
+   * fragment at the same level as its WHERE clause must table-qualify
+   * the WHERE column references (see
+   * StatementGenerator.toWhereStatement's tableAlias option).
    */
   public static buildBucketTimestampSelect(
     resolvedInterval: AggregationInterval,

package/Server/Types/Database/Permissions/OwnerTableRegistry.ts

@@ -14,6 +14,8 @@ import ScheduledMaintenanceOwnerTeamService from "../../../Services/ScheduledMai
 import ScheduledMaintenanceOwnerUserService from "../../../Services/ScheduledMaintenanceOwnerUserService";
 import ServiceOwnerTeamService from "../../../Services/ServiceOwnerTeamService";
 import ServiceOwnerUserService from "../../../Services/ServiceOwnerUserService";
+import ServiceLevelObjectiveOwnerTeamService from "../../../Services/ServiceLevelObjectiveOwnerTeamService";
+import ServiceLevelObjectiveOwnerUserService from "../../../Services/ServiceLevelObjectiveOwnerUserService";
 import HostOwnerTeamService from "../../../Services/HostOwnerTeamService";
 import HostOwnerUserService from "../../../Services/HostOwnerUserService";
 import DockerHostOwnerTeamService from "../../../Services/DockerHostOwnerTeamService";
@@ -144,6 +146,19 @@ const ownerTableRegistry: Map<string, OwnerTablePair> = new Map<
       fkColumn: "runbookId",
     },
   ],
+  [
+    /*
+     * Burn-rate rules are @OwnedThrough their SLO, so this entry is what
+     * lets an Owned-scoped user reach both the SLO and its rules. A missing
+     * entry resolves to "owns nothing" silently (see OwnedScopePermission).
+     */
+    "ServiceLevelObjective",
+    {
+      ownerUserService: ServiceLevelObjectiveOwnerUserService,
+      ownerTeamService: ServiceLevelObjectiveOwnerTeamService,
+      fkColumn: "serviceLevelObjectiveId",
+    },
+  ],
   [
     "ScheduledMaintenance",
     {

package/Server/Utils/AnalyticsDatabase/Statement.ts

@@ -26,16 +26,45 @@ export type StatementParameter = {
   value: RecordValue;
 };
 
+/**
+ * A table-qualified column reference (`table.column`) bound as TWO
+ * Identifier parameters. ClickHouse treats a dotted string bound as a
+ * single Identifier parameter as one quoted identifier (`` `t.col` ``),
+ * so the qualifier and the column must be bound separately.
+ *
+ * Qualification exists so a WHERE built by
+ * StatementGenerator.toWhereStatement can reference the real table
+ * column even when the surrounding SELECT aliases an expression to the
+ * same name — ClickHouse substitutes SELECT aliases into same-level
+ * unqualified WHERE references (an aggregate alias there is an
+ * ILLEGAL_AGGREGATION error; any other alias silently changes the
+ * filter), while qualified references always resolve to the table
+ * column.
+ */
+export class QualifiedColumn {
+  public constructor(
+    public readonly tableAlias: string,
+    public readonly column: string,
+  ) {}
+}
+
 export class Statement implements BaseQueryParams {
   public constructor(
     private strings: string[] = [""],
-    private values: Array<StatementParameter | string> = [],
+    private values: Array<StatementParameter | string | QualifiedColumn> = [],
   ) {}
 
   public get query(): string {
     let query: string = this.strings.reduce(
       (prev: string, curr: string, i: integer) => {
-        const param: StatementParameter | string = this.values[i - 1]!;
+        const param: StatementParameter | string | QualifiedColumn =
+          this.values[i - 1]!;
+
+        if (param instanceof QualifiedColumn) {
+          return (
+            prev + `{p${i - 1}_t:Identifier}.{p${i - 1}_c:Identifier}` + curr
+          );
+        }
 
         const dataType: string =
           typeof param === "string"
@@ -64,6 +93,12 @@ export class Statement implements BaseQueryParams {
     const returnObject: Record<string, unknown> = {};
 
     for (const v of this.values) {
+      if (v instanceof QualifiedColumn) {
+        returnObject[`p${index}_t`] = v.tableAlias;
+        returnObject[`p${index}_c`] = v.column;
+        index++;
+        continue;
+      }
       const finalValue: RecordValue | Array<RecordValue> =
         this.serializseValue(v);
       returnObject[`p${index}`] = finalValue;
@@ -228,11 +263,12 @@ export class Statement implements BaseQueryParams {
  * ClickHouse SQL template literal tag.
  *
  * String substitution values are interpereted as Identifiers (e.g. table or column names),
+ * QualifiedColumn values compile to `table.column` identifier pairs,
  * other substitution values must be StatementParameters.
  */
 export function SQL(
   strings: TemplateStringsArray,
-  ...values: Array<StatementParameter | string>
+  ...values: Array<StatementParameter | string | QualifiedColumn>
 ): Statement {
   return new Statement(strings.slice(0), values.slice(0));
 }