@oneuptime/common 12.0.20 → 12.0.21

package/Models/AnalyticsModels/ChangeEvent.ts

@@ -0,0 +1,331 @@
+import AnalyticsBaseModel from "./AnalyticsBaseModel/AnalyticsBaseModel";
+import Route from "../../Types/API/Route";
+import AnalyticsTableEngine from "../../Types/AnalyticsDatabase/AnalyticsTableEngine";
+import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
+import AnalyticsTableColumn, {
+  SkipIndexType,
+} from "../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+import OperationalResource from "../../Types/Database/AccessControl/OperationalResource";
+import OwnedThrough from "../../Types/Database/AccessControl/OwnedThrough";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import Service from "../DatabaseModels/Service";
+import ServiceType from "../../Types/Telemetry/ServiceType";
+
+/*
+ * Deploys, config changes, scaling events — the "what changed?" signal.
+ * Rows are posted by CI/CD pipelines through the change-events ingest API
+ * (or created from the product) and rendered as vertical dashed markers
+ * on metric charts, so "the spike started 40 seconds after deploy X" is
+ * visible without leaving the chart.
+ *
+ * Peer of LogItemV3 in layout: tenant projectId, per-row retentionDate
+ * TTL, Map(String,String) attributes with a bloom-indexed keys sidecar.
+ * Deliberately narrow — this is an annotation stream, not a log store.
+ */
+
+const readPermissions: Array<Permission> = [
+  Permission.ProjectOwner,
+  Permission.ProjectAdmin,
+  Permission.ProjectMember,
+  Permission.Viewer,
+  Permission.TelemetryAdmin,
+  Permission.TelemetryMember,
+  Permission.TelemetryViewer,
+];
+
+const createPermissions: Array<Permission> = [
+  Permission.ProjectOwner,
+  Permission.ProjectAdmin,
+  Permission.ProjectMember,
+  Permission.TelemetryAdmin,
+  Permission.TelemetryMember,
+];
+
+@OperationalResource()
+@OwnedThrough("primaryEntityId", Service, { includeProjectScope: true })
+export default class ChangeEvent extends AnalyticsBaseModel {
+  public constructor() {
+    const projectIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "projectId",
+      title: "Project ID",
+      description: "ID of project",
+      required: true,
+      type: TableColumnType.ObjectID,
+      isTenantId: true,
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const primaryEntityIdColumn: AnalyticsTableColumn =
+      new AnalyticsTableColumn({
+        key: "primaryEntityId",
+        title: "Service ID",
+        description:
+          "ID of the telemetry Service this change belongs to (the deployed service). Optional — project-wide changes carry none.",
+        required: false,
+        type: TableColumnType.ObjectID,
+        accessControl: {
+          read: readPermissions,
+          create: createPermissions,
+          update: [],
+        },
+      });
+
+    const primaryEntityTypeColumn: AnalyticsTableColumn =
+      new AnalyticsTableColumn({
+        key: "primaryEntityType",
+        isLowCardinality: true,
+        title: "Service Type",
+        description: "Discriminator for primaryEntityId",
+        required: false,
+        type: TableColumnType.Text,
+        accessControl: {
+          read: readPermissions,
+          create: createPermissions,
+          update: [],
+        },
+      });
+
+    const timeColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "time",
+      title: "Time",
+      description: "When the change happened",
+      required: true,
+      type: TableColumnType.DateTime64,
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const eventTypeColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "eventType",
+      isLowCardinality: true,
+      title: "Event Type",
+      description:
+        'Kind of change — e.g. "deployment", "config-change", "scaling", "rollback", "custom"',
+      required: true,
+      defaultValue: "deployment",
+      type: TableColumnType.Text,
+      skipIndex: {
+        name: "idx_change_event_type",
+        type: SkipIndexType.Set,
+        params: [16],
+        granularity: 4,
+      },
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const titleColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "title",
+      title: "Title",
+      description: 'Short human label, e.g. "Deploy v2.31.0"',
+      required: true,
+      type: TableColumnType.Text,
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const descriptionColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "description",
+      title: "Description",
+      description: "Optional detail — commit message, change summary, links",
+      required: false,
+      type: TableColumnType.Text,
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const attributesColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "attributes",
+      codec: { codec: "ZSTD", level: 3 },
+      title: "Attributes",
+      description:
+        "Arbitrary tags — version, commit sha, pipeline url, environment",
+      required: true,
+      defaultValue: {},
+      type: TableColumnType.MapStringString,
+      mapKeysColumn: "attributeKeys",
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const attributeKeysColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "attributeKeys",
+      codec: { codec: "ZSTD", level: 3 },
+      title: "Attribute Keys",
+      description: "Attribute keys extracted from attributes",
+      required: true,
+      defaultValue: [],
+      type: TableColumnType.ArrayText,
+      skipIndex: {
+        name: "idx_attribute_keys",
+        type: SkipIndexType.BloomFilter,
+        params: [0.01],
+        granularity: 1,
+      },
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+      },
+    });
+
+    const retentionDateColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "retentionDate",
+      codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
+      title: "Retention Date",
+      description:
+        "Date after which this row is eligible for TTL deletion, computed at ingest time",
+      required: true,
+      type: TableColumnType.Date,
+      defaultValue: undefined,
+    });
+
+    super({
+      tableName: AnalyticsTableName.ChangeEvent,
+      tableEngine: AnalyticsTableEngine.MergeTree,
+      singularName: "Change Event",
+      accessControl: {
+        read: readPermissions,
+        create: createPermissions,
+        update: [],
+        delete: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.TelemetryAdmin,
+        ],
+      },
+      pluralName: "Change Events",
+      crudApiPath: new Route("/change-events"),
+      enableMCP: true,
+      enableDocumentation: true,
+      tableDescription:
+        "Change events (deployments, config changes, scaling) posted by CI/CD pipelines. Rendered as markers on metric charts so spikes can be correlated with what changed.",
+      tableColumns: [
+        projectIdColumn,
+        primaryEntityIdColumn,
+        primaryEntityTypeColumn,
+        timeColumn,
+        eventTypeColumn,
+        titleColumn,
+        descriptionColumn,
+        attributesColumn,
+        attributeKeysColumn,
+        retentionDateColumn,
+      ],
+      sortKeys: ["projectId", "time"],
+      primaryKeys: ["projectId", "time"],
+      partitionKey: "toYYYYMMDD(time)",
+      /*
+       * Tiny volume (a handful of rows per deploy) — shard by the
+       * always-present tenant + time pair; no hotspot risk at this rate.
+       */
+      shardingKey: "cityHash64(projectId, time)",
+      tableSettings:
+        "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
+      ttlExpression: "retentionDate DELETE",
+      defaultSortColumn: "time",
+    });
+  }
+
+  public get projectId(): ObjectID | undefined {
+    return this.getColumnValue("projectId") as ObjectID | undefined;
+  }
+
+  public set projectId(v: ObjectID | undefined) {
+    this.setColumnValue("projectId", v);
+  }
+
+  public get primaryEntityId(): ObjectID | undefined {
+    return this.getColumnValue("primaryEntityId") as ObjectID | undefined;
+  }
+
+  public set primaryEntityId(v: ObjectID | undefined) {
+    this.setColumnValue("primaryEntityId", v);
+  }
+
+  public get primaryEntityType(): ServiceType | undefined {
+    return this.getColumnValue("primaryEntityType") as ServiceType | undefined;
+  }
+
+  public set primaryEntityType(v: ServiceType | undefined) {
+    this.setColumnValue("primaryEntityType", v);
+  }
+
+  public get time(): Date | undefined {
+    return this.getColumnValue("time") as Date | undefined;
+  }
+
+  public set time(v: Date | undefined) {
+    this.setColumnValue("time", v);
+  }
+
+  public get eventType(): string | undefined {
+    return this.getColumnValue("eventType") as string | undefined;
+  }
+
+  public set eventType(v: string | undefined) {
+    this.setColumnValue("eventType", v);
+  }
+
+  public get title(): string | undefined {
+    return this.getColumnValue("title") as string | undefined;
+  }
+
+  public set title(v: string | undefined) {
+    this.setColumnValue("title", v);
+  }
+
+  public get description(): string | undefined {
+    return this.getColumnValue("description") as string | undefined;
+  }
+
+  public set description(v: string | undefined) {
+    this.setColumnValue("description", v);
+  }
+
+  public get attributes(): JSONObject | undefined {
+    return this.getColumnValue("attributes") as JSONObject | undefined;
+  }
+
+  public set attributes(v: JSONObject | undefined) {
+    this.setColumnValue("attributes", v);
+  }
+
+  public get attributeKeys(): Array<string> | undefined {
+    return this.getColumnValue("attributeKeys") as Array<string> | undefined;
+  }
+
+  public set attributeKeys(v: Array<string> | undefined) {
+    this.setColumnValue("attributeKeys", v);
+  }
+
+  public get retentionDate(): Date | undefined {
+    return this.getColumnValue("retentionDate") as Date | undefined;
+  }
+
+  public set retentionDate(v: Date | undefined) {
+    this.setColumnValue("retentionDate", v);
+  }
+}

package/Models/AnalyticsModels/Index.ts

@@ -21,6 +21,7 @@ import ProfileSample from "./ProfileSample";
 import RumSession from "./RumSession";
 import RumSessionChunk from "./RumSessionChunk";
 import AuditLog from "./AuditLog";
+import ChangeEvent from "./ChangeEvent";
 
 const AnalyticsModels: Array<{ new (): AnalyticsBaseModel }> = [
   Log,
@@ -69,6 +70,7 @@ const AnalyticsModels: Array<{ new (): AnalyticsBaseModel }> = [
   RumSessionChunk,
   AuditLog,
   SecurityEvent,
+  ChangeEvent,
 ];
 
 const modelTypeMap: { [key: string]: { new (): AnalyticsBaseModel } } = {};

package/Server/EnvironmentConfig.ts

@@ -385,17 +385,10 @@ export const AnalyticsHost: string = process.env["ANALYTICS_HOST"] || "";
 export const GoogleTagManagerEnabled: boolean =
   IsBillingEnabled && process.env["GOOGLE_TAG_MANAGER_ENABLED"] !== "false";
 
-/*
- * Shared secret Cal.com signs booking webhooks with (App/API/CalWebhook.ts).
- * Server-only — must never be added to FRONTEND_ENV_ALLOW_LIST. Empty means
- * the webhook endpoint is disabled and answers 503.
- */
-export const CalWebhookSecret: string = process.env["CAL_WEBHOOK_SECRET"] || "";
-
 /*
  * Outbound marketing conversion webhooks.
  *
- * OneUptime does not store conversions. Signups, booked meetings and plan
+ * OneUptime does not store conversions. Signups and plan
  * upgrades/downgrades are POSTed to this endpoint as they happen and kept
  * nowhere afterwards, so an unset URL means those moments are simply not
  * measured — nothing accumulates waiting for one to be configured.

package/Server/Infrastructure/Postgres/SchemaMigrations/1789000000000-AddUserSlackAndMicrosoftTeams.ts

@@ -14,6 +14,10 @@ export class AddUserSlackAndMicrosoftTeams1789000000000
   public name = "AddUserSlackAndMicrosoftTeams1789000000000";
 
   public async up(queryRunner: QueryRunner): Promise<void> {
+    if (await this.isAlreadyApplied(queryRunner)) {
+      return;
+    }
+
     await queryRunner.query(
       `CREATE TABLE "UserSlack" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "slackUserId" character varying(100), "slackUserName" character varying(100), "userId" uuid, "createdByUserId" uuid, "deletedByUserId" uuid, "isVerified" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_86de4cd76b41a08811fc403e23a" PRIMARY KEY ("_id"))`,
     );
@@ -106,6 +110,44 @@ export class AddUserSlackAndMicrosoftTeams1789000000000
     );
   }
 
+  /*
+   * Did everything in `up` already run, under this migration's OLD name?
+   *
+   * This shipped as AddUserSlackAndMicrosoftTeams1788800000000 and was
+   * renumbered to 1789000000000 to clear a timestamp collision with
+   * DropMarketingConversionAddEnterpriseLicenseEmail. TypeORM identifies a
+   * migration by class NAME rather than by what it does, so every database
+   * that had already recorded the old name — anything tracking master between
+   * the two commits, which is every test and staging cluster — sees the
+   * renamed class as pending and runs it a second time, where
+   * `CREATE TABLE "UserSlack"` fails on the table it created itself. The
+   * runner stops at the first failure, so that single error holds back this
+   * migration and every migration added after it, on every boot.
+   *
+   * The probe is the table because the earlier run was all-or-nothing:
+   * migrations run one transaction each (DataSourceOptions sets
+   * migrationsTransactionMode: "each") and Postgres DDL is transactional, so
+   * "UserSlack" existing means every statement in `up` already committed.
+   * Nothing is left to do but let TypeORM record the new name.
+   *
+   * The superseded row in "migrations" is deliberately left alone. Deleting it
+   * would make this migration pending again for anyone who rolls the image
+   * BACK to a build that still registers the old name — the same failure, in
+   * the other direction. An unrecognised name in that table is inert.
+   */
+  private async isAlreadyApplied(queryRunner: QueryRunner): Promise<boolean> {
+    const userSlackTableExists: Array<{ exists: boolean }> =
+      await queryRunner.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_schema = 'public'
+                AND table_name = 'UserSlack'
+            )
+        `);
+
+    return Boolean(userSlackTableExists[0]?.exists);
+  }
+
   public async down(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.query(
       `ALTER TABLE "UserOnCallLogTimeline" DROP CONSTRAINT "FK_a7206c19df5cdfe02cf3215a64c"`,

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -542,7 +542,6 @@ import { RemoveLlmCostBudgetAlertColumns1788500000000 } from "./1788500000000-Re
 import { AddDetectionRuleIncidentColumns1788600000000 } from "./1788600000000-AddDetectionRuleIncidentColumns";
 import { RemoveMarketingConversionUploadState1788700000000 } from "./1788700000000-RemoveMarketingConversionUploadState";
 import { DropMarketingConversionAddEnterpriseLicenseEmail1788800000000 } from "./1788800000000-DropMarketingConversionAddEnterpriseLicenseEmail";
-import { RedactStoredMonitorIngestSecrets1788900000000 } from "./1788900000000-RedactStoredMonitorIngestSecrets";
 import { AddUserSlackAndMicrosoftTeams1789000000000 } from "./1789000000000-AddUserSlackAndMicrosoftTeams";
 import { MigrationName1787142779538 } from "./1787142779538-MigrationName";
 import { MigrationName1787156982416 } from "./1787156982416-MigrationName";
@@ -1094,6 +1093,5 @@ export default [
   AddDetectionRuleIncidentColumns1788600000000,
   RemoveMarketingConversionUploadState1788700000000,
   DropMarketingConversionAddEnterpriseLicenseEmail1788800000000,
-  RedactStoredMonitorIngestSecrets1788900000000,
   AddUserSlackAndMicrosoftTeams1789000000000,
 ];

package/Server/Services/ChangeEventService.ts

@@ -0,0 +1,11 @@
+import ClickhouseDatabase from "../Infrastructure/ClickhouseDatabase";
+import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
+import ChangeEvent from "../../Models/AnalyticsModels/ChangeEvent";
+
+export class ChangeEventService extends AnalyticsDatabaseService<ChangeEvent> {
+  public constructor(clickhouseDatabase?: ClickhouseDatabase | undefined) {
+    super({ modelType: ChangeEvent, database: clickhouseDatabase });
+  }
+}
+
+export default new ChangeEventService();

package/Server/Services/EnterpriseLicenseService.ts

@@ -37,9 +37,9 @@ export class Service extends DatabaseService<EnterpriseLicense> {
         email: createdItem.email?.toString(),
         /*
          * No attribution source. A licence row is typed in by a human and
-         * carries no session, so its campaign is whatever the meeting_booked
-         * sharing its email carried — the join the receiver makes on
-         * emailHash, not something OneUptime can restate here.
+         * carries no session, so its campaign is whatever the earlier
+         * conversion sharing its email carried — the join the receiver makes
+         * on emailHash, not something OneUptime can restate here.
          */
         data: {
           enterpriseLicenseId: createdItem.id?.toString() || "",

package/Server/Services/Index.ts

@@ -77,6 +77,7 @@ import DataSourceService from "./DataSourceService";
 import AuditLogService from "./AuditLogService";
 import LogService from "./LogService";
 import SecurityEventService from "./SecurityEventService";
+import ChangeEventService from "./ChangeEventService";
 import MailService from "./MailService";
 import MetricService from "./MetricService";
 import MetricItemAggMV1mService from "./MetricItemAggMV1mService";
@@ -641,6 +642,7 @@ export const AnalyticsServices: Array<
   RumSessionChunkService,
   AuditLogService,
   SecurityEventService,
+  ChangeEventService,
 ];
 
 export default services;

package/Server/Utils/Attribution.ts

@@ -11,12 +11,12 @@ import { JSONObject, JSONValue } from "../../Types/JSON";
 
 /*
  * Sanitizers for attribution submitted by unauthenticated callers — the signup
- * form, the Cal.com booking webhook, and the enterprise licence request form.
+ * form and the enterprise licence request form.
  *
- * Everything here is a whitelist, never a denylist. Cal booking metadata and
- * form bodies are free-form caller content (names, notes, answers to booking
- * questions), and only the keys named in Common/Types/Marketing/Attribution.ts
- * may be copied into a row that is later forwarded to an ad platform.
+ * Everything here is a whitelist, never a denylist. Form bodies are free-form
+ * caller content (names, notes, free-text answers), and only the keys named in
+ * Common/Types/Marketing/Attribution.ts may be copied into a row that is later
+ * forwarded to an ad platform.
  *
  * This file also owns email normalisation and hashing. Meta and Reddit each
  * used to carry a private copy of the hash, and MarketingConversion.emailHash
@@ -101,10 +101,10 @@ export default class Attribution {
   /*
    * UTM values out of an arbitrary object, accepting either spelling.
    *
-   * A URL and Cal booking metadata carry `utm_source`; a JSON body posted by
-   * the signup page carries `utmSource`. Both arrive at server doors that
-   * write the same columns, so both are read here rather than making each
-   * caller remember which shape it is holding. camelCase wins when a caller
+   * A URL carries `utm_source`; a JSON body posted by the signup page carries
+   * `utmSource`. Both arrive at server doors that write the same columns, so
+   * both are read here rather than making each caller remember which shape it
+   * is holding. camelCase wins when a caller
    * somehow sends both, because that is the spelling the browser writes
    * deliberately and the snake_case one is the raw URL echo.
    */
@@ -180,8 +180,8 @@ export default class Attribution {
 
   /*
    * SHA-256 of the normalised email, hex encoded — the identifier every ad
-   * platform's enhanced matching expects, and the key the conversion ledger
-   * joins a booked meeting to the signup it later produced.
+   * platform's enhanced matching expects, and the key a receiver joins one
+   * person's conversions on.
    */
   public static hashEmail(email: string | undefined): string | null {
     const normalized: string | null = this.normalizeEmail(email);

package/Server/Utils/Marketing/MarketingEventWebhook.ts

@@ -12,8 +12,8 @@ const REQUEST_TIMEOUT_MS: number = 15000;
 /*
  * Delivers marketing conversion events to one operator-configured endpoint.
  *
- * OneUptime keeps no conversion ledger, so this is the only exit for a signup,
- * a booked meeting or a plan change. That has one consequence worth stating
+ * OneUptime keeps no conversion ledger, so this is the only exit for a signup
+ * or a plan change. That has one consequence worth stating
  * plainly: a delivery this class gives up on is gone, because there is no row
  * anywhere to reconcile against later. deliver() therefore THROWS on anything
  * that might succeed on a retry, and the queue is what retries it.
@@ -21,9 +21,8 @@ const REQUEST_TIMEOUT_MS: number = 15000;
  * SIGNING
  *
  * The signature is HMAC-SHA256 over the exact request body bytes, hex encoded,
- * in `x-oneuptime-signature-256`. This is the same scheme OneUptime verifies
- * on the way in from Cal, deliberately: one thing to understand rather than
- * two. The receiver must compute its digest over the raw bytes it received —
+ * in `x-oneuptime-signature-256`. The receiver must compute its digest over
+ * the raw bytes it received —
  * JSON parsed and re-serialised is NOT equivalent, because whitespace, key
  * order and escaping all change the digest.
  *