@oneuptime/common 12.0.23 → 12.0.25

package/Models/AnalyticsModels/Span.ts

@@ -1150,6 +1150,80 @@ export default class Span extends AnalyticsBaseModel {
         accessControl: llmColumnAccessControl,
       });
 
+    /*
+     * Employee identity columns. Denormalized at ingest from the OTel general
+     * semantic-convention identity attributes (user.id / user.email / team.id)
+     * and the gateway + coding-agent fallbacks — see
+     * LlmUserIdAttributeKeys in Common/Types/Telemetry/LlmConventions.ts.
+     *
+     * These answer the question the trace-only LLM feature could not: which
+     * PERSON, and which cost centre, does this spend belong to. They are
+     * populated only on LLM spans (the extractor gates them on isLlmSpan), so
+     * the RUM and HTTP fleet — which also carries user.id — pays nothing for
+     * them.
+     *
+     * They hold real identifying data, so TraceScrubRuleService.scrubSpan
+     * applies the project's Attributes-scoped scrub rules to them just as it
+     * does to the attribute they were derived from.
+     */
+    const llmUserIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "llmUserId",
+      isLowCardinality: true,
+      title: "LLM User ID",
+      description:
+        "Id of the employee / internal actor who made this LLM call (user.id, enduser.id, or the gateway / coding-agent equivalent). NOT the caller's own downstream customer — that identity is deliberately never mapped here. '' when the instrumentation reports none.",
+      required: false,
+      type: TableColumnType.Text,
+      /*
+       * Set index sized like idx_llm_request_model: a project's employee
+       * roster is in the hundreds-to-low-thousands, so 1000 distinct values
+       * per granule keeps the index useful for the "one person's spend"
+       * query without degenerating into a per-granule scan.
+       */
+      skipIndex: {
+        name: "idx_llm_user_id",
+        type: SkipIndexType.Set,
+        params: [1000],
+        granularity: 4,
+      },
+      accessControl: llmColumnAccessControl,
+    });
+
+    const llmUserEmailColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "llmUserEmail",
+      isLowCardinality: true,
+      title: "LLM User Email",
+      description:
+        "Email of the employee / internal actor who made this LLM call (user.email, emitted natively by Claude Code, Gemini CLI and Codex). Subject to the project's Attributes-scoped trace scrub rules. '' when the instrumentation reports none.",
+      required: false,
+      type: TableColumnType.Text,
+      // Same sizing rationale as idx_llm_user_id — one row per employee.
+      skipIndex: {
+        name: "idx_llm_user_email",
+        type: SkipIndexType.Set,
+        params: [1000],
+        granularity: 4,
+      },
+      accessControl: llmColumnAccessControl,
+    });
+
+    const llmTeamColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "llmTeam",
+      isLowCardinality: true,
+      title: "LLM Team",
+      description:
+        "Team / cost centre the LLM spend charges to (team.id, cost_center, department — conventionally set via OTEL_RESOURCE_ATTRIBUTES). '' when none is reported.",
+      required: false,
+      type: TableColumnType.Text,
+      /*
+       * No skip index, mirroring llmResponseModel. Teams number in the tens:
+       * a Set index would match nearly every granule and cost more to read
+       * than the filter it saves, and the LowCardinality dictionary already
+       * makes the column cheap to scan.
+       */
+      accessControl: llmColumnAccessControl,
+    });
+
     const retentionDateColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
       key: "retentionDate",
       codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
@@ -1245,6 +1319,9 @@ export default class Span extends AnalyticsBaseModel {
         llmTotalTokensColumn,
         llmCostColumn,
         llmConversationIdColumn,
+        llmUserIdColumn,
+        llmUserEmailColumn,
+        llmTeamColumn,
         retentionDateColumn,
       ],
       projections: [
@@ -1574,4 +1651,28 @@ export default class Span extends AnalyticsBaseModel {
   public set llmConversationId(v: string | undefined) {
     this.setColumnValue("llmConversationId", v);
   }
+
+  public get llmUserId(): string | undefined {
+    return this.getColumnValue("llmUserId") as string | undefined;
+  }
+
+  public set llmUserId(v: string | undefined) {
+    this.setColumnValue("llmUserId", v);
+  }
+
+  public get llmUserEmail(): string | undefined {
+    return this.getColumnValue("llmUserEmail") as string | undefined;
+  }
+
+  public set llmUserEmail(v: string | undefined) {
+    this.setColumnValue("llmUserEmail", v);
+  }
+
+  public get llmTeam(): string | undefined {
+    return this.getColumnValue("llmTeam") as string | undefined;
+  }
+
+  public set llmTeam(v: string | undefined) {
+    this.setColumnValue("llmTeam", v);
+  }
 }

package/Models/DatabaseModels/DetectionRule.ts

@@ -253,6 +253,61 @@ export default class DetectionRule extends BaseModel {
   })
   public groupByField?: string = undefined;
 
+  /*
+   * The correlation pair: distinctCountField switches what the threshold
+   * counts (unique field values instead of raw events — the difference
+   * between brute-force and one user retyping a password), and
+   * matchCountThreshold holds the rule back until a group reaches N in
+   * one evaluation window. Threshold 1 preserves fire-on-any-match, so
+   * every rule saved before these columns existed behaves unchanged.
+   */
+  @ColumnAccessControl({
+    create: createPermissions,
+    read: readPermissions,
+    update: updatePermissions,
+  })
+  @TableColumn({
+    title: "Distinct Count Field",
+    required: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    description:
+      "Optional security-event field (e.g. principalUser, principalIp) whose distinct values are counted instead of raw matching events. The match count threshold then applies to that distinct count. Empty values are not counted. Names that are not typed event columns are looked up in the event's attributes map.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public distinctCountField?: string = undefined;
+
+  @ColumnAccessControl({
+    create: createPermissions,
+    read: readPermissions,
+    update: updatePermissions,
+  })
+  @TableColumn({
+    title: "Match Count Threshold",
+    required: true,
+    type: TableColumnType.Number,
+    canReadOnRelationQuery: true,
+    description:
+      "Fire only when a group's count — distinct values when a distinct count field is set, matching events otherwise — reaches this number within one evaluation window. 1 fires on any match.",
+    defaultValue: 1,
+    /*
+     * Same reason as shouldCreateIncident: without this,
+     * checkRequiredFields 400s every create payload written before the
+     * column existed, and the DB DEFAULT 1 can never apply.
+     */
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 1,
+  })
+  public matchCountThreshold?: number = undefined;
+
   @ColumnAccessControl({
     create: createPermissions,
     read: readPermissions,

package/Models/DatabaseModels/NetworkDeviceAutoImportRule.ts

@@ -78,6 +78,17 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
   tableDescription:
     "Automatically import matching hosts from network device discovery scan results as Network Devices, with no manual review step",
 })
+/*
+ * The index and foreign-key names below are written out rather than left to
+ * TypeORM's generated hashes, because this table's migration
+ * (1789100000000-AddNetworkDeviceAutoImportRule) was hand-written and created
+ * them with readable names. TypeORM compares constraint NAMES when it diffs a
+ * database against these entities, so an entity that does not spell them out
+ * reports the whole table as schema drift on every run of the Postgres Schema
+ * Drift check — which is what it did until these were added. Naming them here
+ * keeps the readable names and costs no migration; the alternative was an
+ * ALTER that renamed seven objects on every installation to hashes.
+ */
 export default class NetworkDeviceAutoImportRule extends BaseModel {
   @ColumnAccessControl({
     create: [
@@ -112,7 +123,10 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
       orphanedRowAction: "nullify",
     },
   )
-  @JoinColumn({ name: "projectId" })
+  @JoinColumn({
+    name: "projectId",
+    foreignKeyConstraintName: "FK_nd_auto_import_rule_projectId",
+  })
   public project?: Project = undefined;
 
   @ColumnAccessControl({
@@ -130,7 +144,7 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
     ],
     update: [],
   })
-  @Index()
+  @Index("IDX_network_device_auto_import_rule_projectId")
   @TableColumn({
     type: TableColumnType.ObjectID,
     required: true,
@@ -164,7 +178,7 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
       Permission.EditNetworkDeviceAutoImportRule,
     ],
   })
-  @Index()
+  @Index("IDX_network_device_auto_import_rule_name")
   @TableColumn({
     required: true,
     type: TableColumnType.ShortText,
@@ -230,7 +244,7 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
       Permission.EditNetworkDeviceAutoImportRule,
     ],
   })
-  @Index()
+  @Index("IDX_network_device_auto_import_rule_isEnabled")
   @TableColumn({
     required: true,
     type: TableColumnType.Boolean,
@@ -434,7 +448,7 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
       Permission.EditNetworkDeviceAutoImportRule,
     ],
   })
-  @Index()
+  @Index("IDX_network_device_auto_import_rule_isExclusion")
   @TableColumn({
     required: true,
     type: TableColumnType.Boolean,
@@ -485,7 +499,10 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
       orphanedRowAction: "nullify",
     },
   )
-  @JoinColumn({ name: "createdByUserId" })
+  @JoinColumn({
+    name: "createdByUserId",
+    foreignKeyConstraintName: "FK_nd_auto_import_rule_createdByUserId",
+  })
   public createdByUser?: User = undefined;
 
   @ColumnAccessControl({
@@ -541,7 +558,10 @@ export default class NetworkDeviceAutoImportRule extends BaseModel {
       orphanedRowAction: "nullify",
     },
   )
-  @JoinColumn({ name: "deletedByUserId" })
+  @JoinColumn({
+    name: "deletedByUserId",
+    foreignKeyConstraintName: "FK_nd_auto_import_rule_deletedByUserId",
+  })
   public deletedByUser?: User = undefined;
 
   @ColumnAccessControl({

package/Models/DatabaseModels/NetworkDeviceDiscoveryScan.ts

@@ -250,6 +250,73 @@ export default class NetworkDeviceDiscoveryScan extends BaseModel {
   })
   public probeId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDeviceDiscoveryScan,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDeviceDiscoveryScan,
+    ],
+    /*
+     * Updatable, unlike everything that describes the sweep itself: changing
+     * the target or the credentials of a scan mid-flight would mean the stored
+     * row no longer described the sweep that ran, so those grant no update at
+     * all. (The recurrence pair is updatable too — it describes the NEXT run
+     * rather than the one that happened.)
+     *
+     * A name describes nothing but itself, and the whole point of it is to be
+     * fixable after the fact: a scan mislabelled "Region 1100" is worse than
+     * an unnamed one, and deleting a scan to rename it would throw away its
+     * results.
+     */
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDeviceDiscoveryScan,
+    ],
+  })
+  /*
+   * What this scan is FOR, in the operator's own words — "Router Discovery —
+   * Region 1100", "Switch Discovery — WB Units". Optional, not unique, and
+   * never used to look a scan up: it exists so the Discovery Scans list can be
+   * read at a glance instead of by matching octet ranges against a subnet plan
+   * kept somewhere else (OneUptime issue #3391).
+   *
+   * Nullable, and every scan created before this column existed is null — so
+   * every surface that renders it falls back to the scan target. See
+   * Common/Utils/NetworkDiscovery/ScanNameUtil.
+   */
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Name",
+    description:
+      "Optional name for this scan, so it can be told apart from other scans at a glance. Falls back to the scan target when empty.",
+    example: "Router Discovery - Region 1100",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public name?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/Project.ts

@@ -2576,6 +2576,74 @@ export default class Project extends TenantModel {
   })
   public utmContent?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [Permission.User],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmId?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.User],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmSourcePlatform?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.User],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmCreativeFormat?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.User],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmMarketingTactic?: string = undefined;
+
   @ColumnAccessControl({
     create: [Permission.User],
     read: [],

package/Models/DatabaseModels/User.ts

@@ -634,6 +634,74 @@ class User extends UserModel {
   })
   public utmContent?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [Permission.Public],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmId?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.Public],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmSourcePlatform?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.Public],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmCreativeFormat?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.Public],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public utmMarketingTactic?: string = undefined;
+
   @ColumnAccessControl({
     create: [Permission.Public],
     read: [],

package/Server/API/BaseAPI.ts

@@ -147,18 +147,6 @@ export default class BaseAPI<
       },
     );
 
-    router.get(
-      `${new this.entityType().getCrudApiPath()?.toString()}/:id/update-item`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          await this.updateItem(req, res);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-
     // Delete
     router.delete(
       `${new this.entityType().getCrudApiPath()?.toString()}/:id`,
@@ -184,18 +172,6 @@ export default class BaseAPI<
       },
     );
 
-    router.get(
-      `${new this.entityType().getCrudApiPath()?.toString()}/:id/delete-item`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          await this.deleteItem(req, res);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-
     this.router = router;
     this.service = service;
   }

package/Server/API/SlackAPI.ts

@@ -592,7 +592,6 @@ export default class SlackAPI {
           "Slack Interactive Auth Result: ",
           getLogAttributesFromRequest(req as any),
         );
-        logger.debug(authResult, getLogAttributesFromRequest(req as any));
 
         // if slack uninstall app then,
         if (authResult.payloadType === "app_uninstall") {
@@ -886,7 +885,6 @@ export default class SlackAPI {
           "Slack Events API Request received",
           getLogAttributesFromRequest(req as any),
         );
-        logger.debug(req.body, getLogAttributesFromRequest(req as any));
 
         const payload: JSONObject = req.body;
 

package/Server/API/TelemetryAPI.ts

@@ -204,6 +204,13 @@ const requireExceptionReadAccess: Array<RequestHandler> =
 const requireProfileReadAccess: Array<RequestHandler> =
   createTelemetryReadAccessGuard(Permission.ReadTelemetryServiceProfiles);
 
+/*
+ * Mirrors the read access control declared on the SecurityEvent analytics
+ * model.
+ */
+const requireSecurityEventReadAccess: Array<RequestHandler> =
+  createTelemetryReadAccessGuard(Permission.ReadSecurityEvent);
+
 router.post(
   "/telemetry/metrics/get-attributes",
   ...requireMetricReadAccess,
@@ -268,6 +275,28 @@ router.post(
   },
 );
 
+/*
+ * Security events flatten their whole source payload into `attributes`, so
+ * these are what backs the "add an attribute column" picker on the security
+ * events table — the keys differ per event class and per source, so there is
+ * no fixed list the UI could ship.
+ */
+router.post(
+  "/telemetry/security-events/get-attributes",
+  ...requireSecurityEventReadAccess,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    return getAttributes(req, res, next, TelemetryType.SecurityEvent);
+  },
+);
+
+router.post(
+  "/telemetry/security-events/get-attribute-values",
+  ...requireSecurityEventReadAccess,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    return getAttributeValues(req, res, next, TelemetryType.SecurityEvent);
+  },
+);
+
 type GetAttributesFunction = (
   req: ExpressRequest,
   res: ExpressResponse,

package/Server/Infrastructure/Postgres/SchemaMigrations/1789400000000-AddNameToNetworkDeviceDiscoveryScan.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * An optional operator-supplied name on a discovery scan (issue #3391), so the
+ * Discovery Scans list can be read by purpose — "Router Discovery — Region
+ * 1100" — instead of only by the raw address range it sweeps.
+ *
+ * Nullable with no default and no backfill: every scan that already exists
+ * stays unnamed, and every surface that renders the name falls back to the
+ * scan target exactly as it did before this column existed.
+ */
+export class AddNameToNetworkDeviceDiscoveryScan1789400000000
+  implements MigrationInterface
+{
+  public name: string = "AddNameToNetworkDeviceDiscoveryScan1789400000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "name" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "name"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1789500000000-AddCampaignUtmFields.ts

@@ -0,0 +1,49 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * GA4's second tier of campaign parameters, on the two tables that already
+ * carry the first five.
+ *
+ * `utm_id`, `utm_source_platform`, `utm_creative_format` and
+ * `utm_marketing_tactic` arrive on the landing URL from Google Ads auto-tagging
+ * and the GA4 URL builder. Until now the browser captured them nowhere and the
+ * signup door dropped them, so a campaign that distinguished its creatives
+ * only by `utm_creative_format` was reportable as one undifferentiated
+ * campaign.
+ *
+ * Nullable with no default, matching utmSource..utmContent beside them: an
+ * existing row has no campaign to backfill, and NULL says "not known" rather
+ * than claiming an empty campaign.
+ */
+export class AddCampaignUtmFields1789500000000 implements MigrationInterface {
+  public name: string = "AddCampaignUtmFields1789500000000";
+
+  private static readonly columns: Array<string> = [
+    "utmId",
+    "utmSourcePlatform",
+    "utmCreativeFormat",
+    "utmMarketingTactic",
+  ];
+
+  private static readonly tables: Array<string> = ["User", "Project"];
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    for (const table of AddCampaignUtmFields1789500000000.tables) {
+      for (const column of AddCampaignUtmFields1789500000000.columns) {
+        await queryRunner.query(
+          `ALTER TABLE "${table}" ADD "${column}" character varying(500)`,
+        );
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    for (const table of AddCampaignUtmFields1789500000000.tables) {
+      for (const column of AddCampaignUtmFields1789500000000.columns) {
+        await queryRunner.query(
+          `ALTER TABLE "${table}" DROP COLUMN "${column}"`,
+        );
+      }
+    }
+  }
+}