@oneuptime/common 12.0.33 → 12.0.34

package/Models/DatabaseModels/TeamMemberCustomField.ts

@@ -3,6 +3,7 @@ import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Route from "../../Types/API/Route";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+import CustomFieldMappingSourceResource from "../../Types/CustomField/CustomFieldMappingSourceResource";
 import CustomFieldType from "../../Types/CustomField/CustomFieldType";
 import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
 import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
@@ -272,7 +273,7 @@ export default class TeamMemberCustomField extends BaseModel {
   })
   @TableColumn({
     required: false,
-    type: TableColumnType.LongText,
+    type: TableColumnType.VeryLongText,
     title: "Dropdown Options",
     description:
       "Options and optional colors for dropdown fields. Plain one-per-line values remain supported.",
@@ -280,11 +281,84 @@ export default class TeamMemberCustomField extends BaseModel {
   })
   @Column({
     nullable: true,
-    type: ColumnType.LongText,
-    length: ColumnLength.LongText,
+    type: ColumnType.VeryLongText,
   })
   public dropdownOptions?: string = 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.ShortText,
+    title: "Map Value From",
+    description:
+      "Related resource this field copies its value from. Empty means values are entered by hand.",
+    example: "Monitor",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public mapFromResourceType?: CustomFieldMappingSourceResource = 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.ShortText,
+    title: "Map Value From Field",
+    description:
+      "Name of the custom field on the related resource this field copies its value from.",
+    example: "Vendor",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public mapFromCustomFieldName?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/TeamPermission.ts

@@ -42,7 +42,6 @@ import {
   create: [
     Permission.ProjectOwner,
     Permission.ProjectAdmin,
-    Permission.CreateProjectTeam,
     Permission.EditProjectTeamPermissions,
   ],
   read: [
@@ -92,7 +91,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -133,7 +131,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -168,7 +165,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -209,7 +205,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -239,11 +234,7 @@ export default class TeamPermission extends BaseModel {
   public teamId?: ObjectID = undefined;
 
   @ColumnAccessControl({
-    create: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
-    ],
+    create: [Permission.ProjectOwner, Permission.ProjectAdmin],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
@@ -280,11 +271,7 @@ export default class TeamPermission extends BaseModel {
   public createdByUser?: User = undefined;
 
   @ColumnAccessControl({
-    create: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
-    ],
+    create: [Permission.ProjectOwner, Permission.ProjectAdmin],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
@@ -312,11 +299,7 @@ export default class TeamPermission extends BaseModel {
   public createdByUserId?: ObjectID = undefined;
 
   @ColumnAccessControl({
-    create: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
-    ],
+    create: [Permission.ProjectOwner, Permission.ProjectAdmin],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
@@ -376,7 +359,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -416,7 +398,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -467,7 +448,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [
@@ -503,7 +483,6 @@ export default class TeamPermission extends BaseModel {
     create: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
-      Permission.CreateProjectTeam,
       Permission.EditProjectTeamPermissions,
     ],
     read: [

package/Models/DatabaseModels/TelemetryIngestionKey.ts

@@ -15,6 +15,7 @@ import TenantColumn from "../../Types/Database/TenantColumn";
 import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
+import TelemetryIngestionKeyType from "../../Types/Telemetry/TelemetryIngestionKeyType";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 
 @EnableDocumentation()
@@ -321,4 +322,263 @@ export default class TelemetryIngestionKey extends BaseModel {
     transformer: ObjectID.getDatabaseTransformer(),
   })
   public secretKey?: ObjectID = undefined;
+
+  /*
+   * Deliberately IMMUTABLE: create and read, but `update: []`.
+   *
+   * The type of a key is what every ingest-time guard keys off - which
+   * surfaces it may reach, whether an origin allowlist is enforced, whether a
+   * default rate limit applies. Editing it in place would silently change what
+   * a credential that is already deployed is allowed to do, in either
+   * direction: flipping Server -> Browser breaks a collector that has been
+   * shipping traces for a year the moment it sends from no Origin, and
+   * flipping Browser -> Server strips the origin binding off a key that is
+   * still sitting in a public page, which is the single control stopping
+   * anyone who scraped it from writing forged telemetry.
+   *
+   * Neither is a change anyone should be able to make by ticking a box in a
+   * form, and both have a safe alternative that is barely more work: create a
+   * second key of the right type, move traffic to it, delete the old one.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryIngestionKey,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "Key Type",
+    description:
+      "Server keys are for backend services and OpenTelemetry collectors: full ingest, no origin checks. Browser keys are meant to be published in a web page, so they are write-only, restricted to trace / log / metric / session replay ingest, and are only accepted from the origins you list below. This cannot be changed after the key is created - create a new key instead.",
+    defaultValue: TelemetryIngestionKeyType.Server,
+    example: TelemetryIngestionKeyType.Server,
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: false,
+    default: TelemetryIngestionKeyType.Server,
+  })
+  public keyType?: TelemetryIngestionKeyType = undefined;
+
+  /*
+   * Required in practice on a Browser key even though the column itself is
+   * `required: false`. The database cannot express "non-empty only when
+   * keyType is Browser", so the emptiness rule is enforced on the write path
+   * and again at ingest time; the column keeps a '[]' default so that every
+   * pre-existing Server row backfills without a value and behaves exactly as
+   * it always has.
+   *
+   * Note the polarity is the OPPOSITE of
+   * RumApplication.sessionReplayAllowedOrigins, where an empty list accepts
+   * any origin. That column is an optional hardening control retrofitted onto
+   * a shipped feature and could not be tightened without breaking live
+   * installations. A Browser key is new, so it starts closed: a public
+   * credential with no origin binding is not a credential at all.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryIngestionKey,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryIngestionKey,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.JSON,
+    title: "Allowed Origins",
+    description:
+      "Browser origins (scheme + host + port, for example https://app.example.com, or https://*.example.com for one level of subdomain) that may use this key. Required and strictly enforced on a Browser key: a request from an unlisted origin, or with no Origin header at all, is refused. Ignored entirely on a Server key.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: false,
+    default: () => {
+      return "'[]'";
+    },
+  })
+  public allowedOrigins?: Array<string> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryIngestionKey,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryIngestionKey,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Pinned Service Name",
+    description:
+      "When set, every OpenTelemetry resource ingested with this key has its service.name REPLACED with this value. This is what stops data written with a scraped key from masquerading as another service: forged spans land in one service you can see and mute, instead of poisoning your backend services' dashboards and alerts.",
+    example: "checkout-web",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public pinnedServiceName?: string = undefined;
+
+  /*
+   * The kill switch. Separate from deleting the key because the response to
+   * "this key is being abused" and the response to "this key is no longer
+   * needed" are different: turning it off stops the writes in one edit and is
+   * reversible if you were wrong, while keeping the row (and its id) around so
+   * the ingest logs still name something that exists.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryIngestionKey,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryIngestionKey,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Enabled",
+    description:
+      "Turn this off to immediately stop accepting telemetry written with this key, without deleting it. Turn it back on to resume.",
+    defaultValue: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: true,
+  })
+  public isEnabled?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryIngestionKey,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryIngestionKey,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "Expires At",
+    description:
+      "Date and time after which this key stops being accepted. Empty means it never expires, which is how every key behaved before this column existed. Setting one on a Browser key bounds how long a scraped copy stays useful.",
+    example: "2025-12-31T23:59:59Z",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public expiresAt?: Date = undefined;
+
+  /*
+   * Written by the ingest path only, hence `create: []` and `update: []`: a
+   * value a customer could set by hand would be worthless for the one question
+   * it exists to answer - "is anything still using this key, and can I safely
+   * delete or rotate it?"
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "Last Used At",
+    description:
+      "The last time telemetry was accepted with this key. Empty means it has never been used since this was recorded. Use it to find keys that are safe to rotate or delete.",
+    example: "2025-12-31T23:59:59Z",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public lastUsedAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryIngestionKey,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadTelemetryIngestionKey,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryIngestionKey,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Requests Per Minute Limit",
+    description:
+      "Maximum ingest requests per minute accepted with this key. Leave empty to use the shipped default for a Browser key, and to leave a Server key unlimited. The limit is per key, across every client using it, so it has to clear your whole fleet - see DEFAULT_BROWSER_KEY_REQUESTS_PER_MINUTE for the default and the reasoning behind its size.",
+    example: 6000,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: true,
+  })
+  public requestsPerMinuteLimit?: number = undefined;
 }

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;
+});