@oneuptime/common 12.0.32 → 12.0.34

package/Models/DatabaseModels/UserNotificationEmailRollupSetting.ts

@@ -0,0 +1,282 @@
+import Project from "./Project";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import AllowAccessIfSubscriptionIsUnpaid from "../../Types/Database/AccessControl/AllowAccessIfSubscriptionIsUnpaid";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import CurrentUserCanAccessRecordBy from "../../Types/Database/CurrentUserCanAccessRecordBy";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+
+/*
+ * One person's answer, in one project, to "may OneUptime hold my owner
+ * notification emails back during a burst?"
+ *
+ * WHY THIS IS ITS OWN TABLE RATHER THAN A COLUMN ON UserNotificationSetting.
+ * That table is keyed on (user, project, eventType) and a member has 26 rows in
+ * it. "Do not batch my email" is one answer, not twenty-six, and putting it
+ * there would mean a single toggle had to write every row - twenty-six API
+ * calls, twenty-six chances to half-apply, and a state where a user is opted
+ * out of batching for incidents but not for alerts because one write failed.
+ * One row per (user, project) is the shape of the actual preference.
+ *
+ * WHY ABSENT MEANS ENABLED. Burst rollup is on by default and there is no
+ * backfill, so the overwhelming majority of users will never have a row here.
+ * The read path treats "no row" and "isEnabled = true" identically, which is
+ * what lets this ship without touching a single existing install's data.
+ *
+ * WHY IT IS NOT PROJECT-SCOPED POLICY. An admin turning batching off for
+ * everybody is a different feature with a different blast radius. This is the
+ * escape hatch for the individual whose inbox filters, or whose habits, depend
+ * on one email per event - and their colleague in the same project is
+ * unaffected by their choice.
+ */
+@TenantColumn("projectId")
+@AllowAccessIfSubscriptionIsUnpaid()
+@TableAccessControl({
+  create: [Permission.CurrentUser],
+  read: [Permission.CurrentUser],
+  delete: [Permission.CurrentUser],
+  update: [Permission.CurrentUser],
+})
+@CrudApiEndpoint(new Route("/user-notification-email-rollup-setting"))
+@Entity({
+  name: "UserNotificationEmailRollupSetting",
+})
+@TableMetadata({
+  tableName: "UserNotificationEmailRollupSetting",
+  singularName: "Email Rollup Setting",
+  pluralName: "Email Rollup Settings",
+  icon: IconProp.Email,
+  tableDescription:
+    "Whether this user's owner notification emails may be coalesced into a single rollup email during a burst.",
+})
+@CurrentUserCanAccessRecordBy("userId")
+class UserNotificationEmailRollupSetting extends BaseModel {
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+    example: "5f8b9c0d-e1a2-4b3c-8d5e-6f7a8b9c0d1e",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "User",
+    description: "Relation to the User whose preference this is",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userId" })
+  public user?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "User ID",
+    description: "ID of the User whose preference this is",
+    example: "7c9d8e0f-a1b2-4c3d-9e5f-8a7b9c0d1e2f",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userId?: ObjectID = undefined;
+
+  /*
+   * TRUE means "you may hold my email back during a burst" and is the default
+   * for everybody, including every user who has no row here at all. FALSE is
+   * the escape hatch: every owner notification arrives as its own email the
+   * moment it happens, exactly as the product behaved before rollup existed.
+   *
+   * Nothing about this reaches an on-call page, an authentication email or a
+   * billing notice - none of those cross the seam this preference is read at,
+   * so there is no setting here that can make somebody unreachable.
+   */
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [Permission.CurrentUser],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Roll Up Notification Emails",
+    description:
+      "When on, owner notification emails that arrive in a burst are delivered as a single rollup email. When off, every notification is emailed individually and immediately.",
+    defaultValue: true,
+    example: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: true,
+  })
+  public isEnabled?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+    example: "7c9d8e0f-a1b2-4c3d-9e5f-8a7b9c0d1e2f",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+    example: "7c9d8e0f-a1b2-4c3d-9e5f-8a7b9c0d1e2f",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+}
+
+export default UserNotificationEmailRollupSetting;

package/Models/DatabaseModels/UserTelegram.ts

@@ -17,7 +17,6 @@ import TenantColumn from "../../Types/Database/TenantColumn";
 import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
-import Text from "../../Types/Text";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 
 /*
@@ -356,9 +355,6 @@ class UserTelegram extends BaseModel {
     computed: true,
     required: true,
     type: TableColumnType.ShortText,
-    forceGetDefaultValueOnCreate: () => {
-      return Text.generateRandomNumber(6);
-    },
   })
   @Column({
     type: ColumnType.ShortText,

package/Scripts/benchmark-fanin-capacity.js

@@ -0,0 +1,181 @@
+/*
+ * Isolated fan-in admission benchmark against the actual writer source.
+ * Run with the supported Node runtime from the repository root:
+ *
+ *   node --expose-gc Common/Scripts/benchmark-fanin-capacity.js
+ *
+ * Compare in separate processes, extracting the previous source without
+ * modifying the checkout (the revision is the pre-change master):
+ *
+ *   git show 0b23baed11:Common/Server/Utils/Telemetry/TelemetryFanInWriter.ts > /tmp/oneuptime-fanin-before.ts
+ *   node --expose-gc Common/Scripts/benchmark-fanin-capacity.js /tmp/oneuptime-fanin-before.ts
+ *
+ * 200 producers submit chunks sequentially and await all their acceptance
+ * acknowledgements at the end, as ingest jobs do. ClickHouse remains blocked
+ * during measurement. The only changes between runs are the selected writer
+ * source. I/O, logging, shutdown registration and token generation are stubbed.
+ * Heap deltas include rows still held by blocked callers, not just admitted
+ * buffers; exact values vary with V8. These are isolated workload measurements,
+ * not estimates of total deployment memory savings or throughput.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const vm = require("vm");
+const ts = require("typescript");
+
+if (typeof global.gc !== "function") {
+  throw new Error("Run this benchmark with node --expose-gc.");
+}
+
+const sourcePath = path.resolve(
+  process.argv[2] ||
+    path.join(__dirname, "../Server/Utils/Telemetry/TelemetryFanInWriter.ts"),
+);
+const code = ts.transpileModule(fs.readFileSync(sourcePath, "utf8"), {
+  compilerOptions: {
+    module: ts.ModuleKind.CommonJS,
+    target: ts.ScriptTarget.ES2020,
+    esModuleInterop: true,
+  },
+}).outputText;
+let nextToken = 0;
+const overrides = {
+  "../Logger": { debug() {}, info() {}, warn() {}, error() {} },
+  "../../../Types/Sleep": {
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  },
+  "../../../Utils/UUID": {
+    generateTimeOrdered: () => String(nextToken++),
+  },
+  "../GracefulShutdown": {
+    __esModule: true,
+    default: { registerHandler() {} },
+    ShutdownPriority: { Buffers: 1 },
+  },
+  "../AnalyticsDatabase/InsertDedupContext": {
+    nextInsertDedupToken: () => undefined,
+  },
+  "@clickhouse/client": { ClickHouseError: class extends Error {} },
+};
+const sandbox = {
+  exports: {},
+  process,
+  setTimeout,
+  clearTimeout,
+  require: (name) => {
+    if (!(name in overrides)) {
+      throw new Error(`Unexpected writer dependency: ${name}`);
+    }
+    return overrides[name];
+  },
+};
+vm.runInNewContext(code, sandbox, { filename: sourcePath });
+
+async function nextTurn() {
+  await new Promise((resolve) => setImmediate(resolve));
+}
+
+async function collect() {
+  for (let i = 0; i < 3; i++) {
+    global.gc();
+    await nextTurn();
+  }
+}
+
+async function main() {
+  const producerCount = 200;
+  const chunksPerProducer = 3;
+  const rowsPerChunk = 100;
+  const rowBodyBytes = 512;
+  const maxPendingRows = 1000;
+  const writer = new sandbox.exports.TelemetryFanInWriter({
+    maxBatchRows: 500,
+    maxPendingRows,
+    maxConcurrentInserts: 4,
+    maxWaitMs: 60_000,
+    retryMaxAttempts: 1,
+    retryBaseDelayMs: 1,
+    retryMaxDelayMs: 1,
+  });
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  let insertedRows = 0;
+  const target = {
+    model: { tableName: "CapacityBenchmark" },
+    insertJsonRows: async (rows) => {
+      await gate;
+      insertedRows += rows.length;
+    },
+  };
+
+  await collect();
+  const heapBefore = process.memoryUsage().heapUsed;
+  let createdRows = 0;
+  let acceptedSubmissions = 0;
+  const producers = Array.from(
+    { length: producerCount },
+    async (_, producer) => {
+      const acks = [];
+      for (let chunk = 0; chunk < chunksPerProducer; chunk++) {
+        const rows = Array.from({ length: rowsPerChunk }, (_, row) => {
+          createdRows++;
+          return {
+            producer,
+            chunk,
+            row,
+            // A flat, separately allocated body for each row.
+            body: Buffer.alloc(rowBodyBytes / 2, row % 256).toString("hex"),
+          };
+        });
+        const { flushed } = await writer.submit(target, rows);
+        acceptedSubmissions++;
+        acks.push(flushed);
+      }
+      await Promise.all(acks);
+    },
+  );
+
+  try {
+    await nextTurn();
+    await collect();
+    const heapDeltaMiB =
+      (process.memoryUsage().heapUsed - heapBefore) / 1024 / 1024;
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          node: process.version,
+          sourcePath,
+          producerCount,
+          chunksPerProducer,
+          rowsPerChunk,
+          rowBodyBytes,
+          maxPendingRows,
+          createdRows,
+          acceptedSubmissions,
+          ...writer.getStats(),
+          heapDeltaMiB: Number(heapDeltaMiB.toFixed(2)),
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  } finally {
+    release();
+    await writer.flushAll();
+    await Promise.all(producers);
+    if (insertedRows !== producerCount * chunksPerProducer * rowsPerChunk) {
+      throw new Error(`Writer lost rows: inserted ${insertedRows}.`);
+    }
+    if (writer.getStats().pendingRows !== 0) {
+      throw new Error("Writer retained pending rows after drain.");
+    }
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.stack || error}\n`);
+  process.exitCode = 1;
+});