@oneuptime/common 12.0.19 → 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/API/EnterpriseLicenseAPI.ts

@@ -1,7 +1,6 @@
 import EnterpriseLicense from "../../Models/DatabaseModels/EnterpriseLicense";
 import EnterpriseLicenseInstance from "../../Models/DatabaseModels/EnterpriseLicenseInstance";
 import BadDataException from "../../Types/Exception/BadDataException";
-import { JSONObject } from "../../Types/JSON";
 import PartialEntity from "../../Types/Database/PartialEntity";
 import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
 import EnterpriseLicenseUsageUtil from "../../Utils/EnterpriseLicense/EnterpriseLicenseUsage";
@@ -26,6 +25,20 @@ import {
 import BaseAPI from "./BaseAPI";
 // import { Host } from "../EnvironmentConfig";
 
+/*
+ * The license state every installation of a license key mirrors locally.
+ * Returned by both /validate and /report-user-count so that the daily report
+ * keeps a self-hosted installation current on its own.
+ */
+export interface LicenseTerms {
+  companyName: string;
+  // ISO 8601, or null for a license with no expiry set.
+  expiresAt: string | null;
+  licenseKey: string;
+  // Null means the license carries no seat limit.
+  userLimit: number | null;
+}
+
 export interface LicenseInstanceUpsert {
   licenseId: ObjectID;
   instanceId: string;
@@ -137,24 +150,15 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
           const instances: Array<EnterpriseLicenseInstance> =
             await this.findLicenseInstances(license.id!);
 
-          const payload: JSONObject = {
-            companyName: license.companyName || "",
-            expiresAt: license.expiresAt.toISOString(),
-            licenseKey: license.licenseKey || "",
-            userLimit:
-              typeof license.userLimit === "number" ? license.userLimit : null,
-          };
-
-          const token: string = JSONWebToken.signJsonPayload(
-            payload,
-            Math.max(secondsUntilExpiry, 1),
-          );
+          const terms: LicenseTerms = this.getLicenseTerms(license);
+
+          const token: string | null = this.signLicenseToken(license);
 
           return Response.sendJsonObjectResponse(req, res, {
-            companyName: payload["companyName"] as string,
-            expiresAt: payload["expiresAt"] as string,
-            licenseKey: payload["licenseKey"] as string,
-            userLimit: payload["userLimit"],
+            companyName: terms.companyName,
+            expiresAt: terms.expiresAt,
+            licenseKey: terms.licenseKey,
+            userLimit: terms.userLimit,
             currentUserCount:
               typeof license.currentUserCount === "number"
                 ? license.currentUserCount
@@ -202,8 +206,19 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
               query: {
                 licenseKey: licenseKey,
               },
+              /*
+               * The full set of terms, not just the usage columns: this
+               * response is what a self-hosted installation mirrors into its
+               * own GlobalConfig every day, so anything it is missing here is
+               * a field the customer keeps the stale value of until somebody
+               * re-types the license key by hand. Same indexed lookup either
+               * way.
+               */
               select: {
                 _id: true,
+                companyName: true,
+                expiresAt: true,
+                licenseKey: true,
                 userLimit: true,
                 isEvaluationLicense: true,
               },
@@ -282,13 +297,25 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             });
           }
 
+          const terms: LicenseTerms = this.getLicenseTerms(license);
+
           return Response.sendJsonObjectResponse(req, res, {
+            companyName: terms.companyName,
+            expiresAt: terms.expiresAt,
+            licenseKey: terms.licenseKey,
+            userLimit: terms.userLimit,
             currentUserCount: currentUserCount,
             userCountUpdatedAt: reportedAt.toISOString(),
-            userLimit:
-              typeof license.userLimit === "number" ? license.userLimit : null,
             isEvaluationLicense: Boolean(license.isEvaluationLicense),
             instances: this.getInstanceSummaries(instances),
+            /*
+             * Null once the license has expired. Unlike /validate this route
+             * does not reject an expired license - the instance is still
+             * expected to report, and the expiry notification emails are built
+             * from what it reports - but it must not keep being handed a fresh
+             * token, and the expiresAt above is what tells it the truth.
+             */
+            token: this.signLicenseToken(license),
           });
         } catch (err) {
           next(err);
@@ -297,6 +324,54 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
     );
   }
 
+  /*
+   * The license terms a self-hosted installation mirrors locally. Built in one
+   * place so /validate and /report-user-count cannot drift: the seat limit was
+   * missing from what an instance could refresh for exactly as long as the two
+   * responses were written out by hand, separately.
+   */
+  private getLicenseTerms(license: EnterpriseLicense): LicenseTerms {
+    return {
+      companyName: license.companyName || "",
+      expiresAt: license.expiresAt ? license.expiresAt.toISOString() : null,
+      licenseKey: license.licenseKey || "",
+      userLimit:
+        typeof license.userLimit === "number" ? license.userLimit : null,
+    };
+  }
+
+  /*
+   * Signed with the license server's own secret, so it is opaque to the
+   * installation holding it - it is the proof that oneuptime.com recognized
+   * the key, and the instance only checks that it exists. An expired license
+   * gets none, which is why this returns null rather than a short-lived token.
+   */
+  private signLicenseToken(license: EnterpriseLicense): string | null {
+    if (!license.expiresAt) {
+      return null;
+    }
+
+    const secondsUntilExpiry: number = Math.floor(
+      (license.expiresAt.getTime() - Date.now()) / 1000,
+    );
+
+    if (secondsUntilExpiry <= 0) {
+      return null;
+    }
+
+    const terms: LicenseTerms = this.getLicenseTerms(license);
+
+    return JSONWebToken.signJsonPayload(
+      {
+        companyName: terms.companyName,
+        expiresAt: terms.expiresAt,
+        licenseKey: terms.licenseKey,
+        userLimit: terms.userLimit,
+      },
+      Math.max(secondsUntilExpiry, 1),
+    );
+  }
+
   private parseShortText(value: unknown): string {
     if (typeof value !== "string") {
       return "";

package/Server/EnvironmentConfig.ts

@@ -369,16 +369,26 @@ export const AnalyticsKey: string = process.env["ANALYTICS_KEY"] || "";
 export const AnalyticsHost: string = process.env["ANALYTICS_HOST"] || "";
 
 /*
- * 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.
+ * Whether this deployment loads the Google Tag Manager container and pushes
+ * marketing conversions into it.
+ *
+ * Billing being enabled is necessary — a self-hosted install must never load
+ * googletagmanager.com — but it is not sufficient. CI runs the SaaS end-to-end
+ * suite with BILLING_ENABLED forced to true, and those scripted registrations
+ * fire a real `sign_up` into the production container: the key-events trigger
+ * matches on the event name alone, with no hostname condition, and GA4 data
+ * filters do not apply retroactively. This is the second condition, so an
+ * environment can keep billing on and still stay out of the container.
+ *
+ * Defaults to on, so the hosted product needs no deploy change.
  */
-export const CalWebhookSecret: string = process.env["CAL_WEBHOOK_SECRET"] || "";
+export const GoogleTagManagerEnabled: boolean =
+  IsBillingEnabled && process.env["GOOGLE_TAG_MANAGER_ENABLED"] !== "false";
 
 /*
  * 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;