@oneuptime/common 11.5.9 → 11.5.10

package/Models/DatabaseModels/User.ts

@@ -18,6 +18,7 @@ import TableMetadata from "../../Types/Database/TableMetadata";
 import Email from "../../Types/Email";
 import HashedString from "../../Types/HashedString";
 import IconProp from "../../Types/Icon/IconProp";
+import { JSONObject } from "../../Types/JSON";
 import Name from "../../Types/Name";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
@@ -618,6 +619,42 @@ class User extends UserModel {
   })
   public utmUrl?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [Permission.Public],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    hideColumnInDocumentation: true,
+    title: "Ad Click IDs",
+    description:
+      "Ad platform click identifiers (gclid, fbclid, msclkid, etc.) captured on the visit that led to signup. Used for offline conversion uploads to ad platforms.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public clickIds?: JSONObject = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.Public],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    hideColumnInDocumentation: true,
+    title: "First Touch Attribution",
+    description:
+      "UTM parameters, click IDs, landing URL and referrer from the visitor's first attributed visit. The utm* columns hold last-touch values.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public firstTouchAttribution?: JSONObject = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Server/API/BaseAnalyticsAPI.ts

@@ -327,6 +327,23 @@ export default class BaseAnalyticsAPI<
     );
   }
 
+  /*
+   * Server-side clamp on the client-sent aggregate limit — nothing else
+   * bounds it, so an arbitrary client could request limit=999999999
+   * rows. Clamped to LIMIT_PER_PROJECT (never lower): grouped chart
+   * queries legitimately use the full 10k (groups × buckets).
+   * Non-numeric/absent limits are left untouched for the service layer's
+   * own defaulting.
+   */
+  public static clampAggregateLimit(
+    aggregateBy: AggregateBy<AnalyticsDataModel>,
+  ): void {
+    const requestedLimit: number = Number(aggregateBy.limit);
+    if (Number.isFinite(requestedLimit) && requestedLimit > LIMIT_PER_PROJECT) {
+      aggregateBy.limit = LIMIT_PER_PROJECT;
+    }
+  }
+
   @CaptureSpan()
   public async getAggregate(
     req: ExpressRequest,
@@ -357,6 +374,12 @@ export default class BaseAnalyticsAPI<
       throw new BadRequestException("AggregateBy is required");
     }
 
+    /*
+     * Applied before the cache key is computed so an over-limit request
+     * shares the cache slot of its clamped equivalent.
+     */
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
     const databaseProps: DatabaseCommonInteractionProps =
       await CommonAPI.getDatabaseCommonInteractionProps(req);
 

package/Server/API/EnterpriseLicenseAPI.ts

@@ -32,6 +32,7 @@ export interface LicenseInstanceUpsert {
   // Usage fields are only set on report-user-count, not on validate.
   userCount?: number | undefined;
   userEmailHashes?: Array<string> | undefined;
+  masterAdminEmails?: Array<string> | undefined;
   lastReportedAt?: Date | undefined;
 }
 
@@ -215,6 +216,10 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes(
               req.body["userEmailHashes"],
             );
+          const masterAdminEmails: Array<string> =
+            EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails(
+              req.body["masterAdminEmails"],
+            );
 
           if (instanceId) {
             /*
@@ -227,6 +232,7 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
               host: instanceHost || undefined,
               userCount: userCount,
               userEmailHashes: userEmailHashes,
+              masterAdminEmails: masterAdminEmails,
               lastReportedAt: reportedAt,
             });
           }
@@ -372,6 +378,10 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
       newInstance.userEmailHashes = data.userEmailHashes;
     }
 
+    if (data.masterAdminEmails !== undefined) {
+      newInstance.masterAdminEmails = data.masterAdminEmails;
+    }
+
     if (data.lastReportedAt !== undefined) {
       newInstance.lastReportedAt = data.lastReportedAt;
     }
@@ -432,6 +442,10 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
       updateData.userEmailHashes = data.userEmailHashes;
     }
 
+    if (data.masterAdminEmails !== undefined) {
+      updateData.masterAdminEmails = data.masterAdminEmails;
+    }
+
     if (data.lastReportedAt !== undefined) {
       updateData.lastReportedAt = data.lastReportedAt;
     }

package/Server/EnvironmentConfig.ts

@@ -337,6 +337,90 @@ export const SubscriptionPlans: Array<SubscriptionPlan> =
 export const AnalyticsKey: string = process.env["ANALYTICS_KEY"] || "";
 export const AnalyticsHost: string = process.env["ANALYTICS_HOST"] || "";
 
+/*
+ * Google Ads offline conversion uploads (MarketingConversions worker job).
+ * Server-only secrets — must never be added to FRONTEND_ENV_ALLOW_LIST.
+ */
+export const GoogleAdsDeveloperToken: string =
+  process.env["GOOGLE_ADS_DEVELOPER_TOKEN"] || "";
+export const GoogleAdsOAuthClientId: string =
+  process.env["GOOGLE_ADS_OAUTH_CLIENT_ID"] || "";
+export const GoogleAdsOAuthClientSecret: string =
+  process.env["GOOGLE_ADS_OAUTH_CLIENT_SECRET"] || "";
+export const GoogleAdsOAuthRefreshToken: string =
+  process.env["GOOGLE_ADS_OAUTH_REFRESH_TOKEN"] || "";
+// Digits only, no dashes (e.g. 1234567890).
+export const GoogleAdsCustomerId: string =
+  process.env["GOOGLE_ADS_CUSTOMER_ID"] || "";
+// Manager (MCC) account id when the OAuth user accesses the account via a manager.
+export const GoogleAdsLoginCustomerId: string =
+  process.env["GOOGLE_ADS_LOGIN_CUSTOMER_ID"] || "";
+/*
+ * Google sunsets Ads API versions roughly yearly (v20 died 2026-06-10) —
+ * keep this default on a currently supported version and prefer setting
+ * GOOGLE_ADS_API_VERSION explicitly in production.
+ */
+export const GoogleAdsApiVersion: string =
+  process.env["GOOGLE_ADS_API_VERSION"] || "v23";
+// Numeric conversion action ids from Google Ads (Goals -> Conversions).
+export const GoogleAdsSignUpConversionActionId: string =
+  process.env["GOOGLE_ADS_SIGNUP_CONVERSION_ACTION_ID"] || "";
+export const GoogleAdsPaidSubscriptionConversionActionId: string =
+  process.env["GOOGLE_ADS_PAID_SUBSCRIPTION_CONVERSION_ACTION_ID"] || "";
+
+// Meta (Facebook) Conversions API. Server-only secrets.
+export const MetaConversionsPixelId: string =
+  process.env["META_CONVERSIONS_PIXEL_ID"] || "";
+export const MetaConversionsAccessToken: string =
+  process.env["META_CONVERSIONS_ACCESS_TOKEN"] || "";
+export const MetaGraphApiVersion: string =
+  process.env["META_GRAPH_API_VERSION"] || "v22.0";
+
+// Microsoft Advertising (Bing Ads) offline conversions. Server-only secrets.
+export const MicrosoftAdsDeveloperToken: string =
+  process.env["MICROSOFT_ADS_DEVELOPER_TOKEN"] || "";
+export const MicrosoftAdsOAuthClientId: string =
+  process.env["MICROSOFT_ADS_OAUTH_CLIENT_ID"] || "";
+export const MicrosoftAdsOAuthClientSecret: string =
+  process.env["MICROSOFT_ADS_OAUTH_CLIENT_SECRET"] || "";
+export const MicrosoftAdsOAuthRefreshToken: string =
+  process.env["MICROSOFT_ADS_OAUTH_REFRESH_TOKEN"] || "";
+export const MicrosoftAdsCustomerId: string =
+  process.env["MICROSOFT_ADS_CUSTOMER_ID"] || "";
+export const MicrosoftAdsAccountId: string =
+  process.env["MICROSOFT_ADS_ACCOUNT_ID"] || "";
+// Offline conversion goals are matched by NAME in Microsoft Advertising.
+export const MicrosoftAdsSignUpConversionName: string =
+  process.env["MICROSOFT_ADS_SIGNUP_CONVERSION_NAME"] || "";
+export const MicrosoftAdsPaidSubscriptionConversionName: string =
+  process.env["MICROSOFT_ADS_PAID_SUBSCRIPTION_CONVERSION_NAME"] || "";
+
+// LinkedIn Conversions API. Server-only secrets.
+export const LinkedInConversionsAccessToken: string =
+  process.env["LINKEDIN_CONVERSIONS_ACCESS_TOKEN"] || "";
+/*
+ * LinkedIn publishes a new Marketing API version monthly and supports each
+ * for ~12 months — keep this default recent and prefer setting
+ * LINKEDIN_API_VERSION explicitly in production.
+ */
+export const LinkedInApiVersion: string =
+  process.env["LINKEDIN_API_VERSION"] || "202606";
+// Numeric conversion rule ids (urn:lla:llaPartnerConversion:{id}).
+export const LinkedInSignUpConversionId: string =
+  process.env["LINKEDIN_SIGNUP_CONVERSION_ID"] || "";
+export const LinkedInPaidSubscriptionConversionId: string =
+  process.env["LINKEDIN_PAID_SUBSCRIPTION_CONVERSION_ID"] || "";
+
+// Reddit Conversions API. Server-only secrets.
+export const RedditAdsOAuthClientId: string =
+  process.env["REDDIT_ADS_OAUTH_CLIENT_ID"] || "";
+export const RedditAdsOAuthClientSecret: string =
+  process.env["REDDIT_ADS_OAUTH_CLIENT_SECRET"] || "";
+export const RedditAdsOAuthRefreshToken: string =
+  process.env["REDDIT_ADS_OAUTH_REFRESH_TOKEN"] || "";
+export const RedditAdsAccountId: string =
+  process.env["REDDIT_ADS_ACCOUNT_ID"] || "";
+
 export const DisableAutomaticIncidentCreation: boolean =
   process.env["DISABLE_AUTOMATIC_INCIDENT_CREATION"] === "true";
 

package/Server/Infrastructure/Postgres/SchemaMigrations/1784191414522-AddCounterSemanticsToMetricType.ts

@@ -0,0 +1,38 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * OpenTelemetry stamps isMonotonic / aggregationTemporality on every
+ * ClickHouse metric row at ingest, but the browser only ever reads the
+ * Postgres MetricType catalog (name/description/unit). Denormalize both
+ * counter-semantics fields onto the catalog so the metric explorer can
+ * auto-suggest a rate view for cumulative monotonic counters.
+ *
+ * Both columns are nullable: NULL means "not reported yet" (rows created
+ * before this migration, or metrics whose instrument type carries no
+ * monotonicity — e.g. gauges). The ingest upsert only writes the fields
+ * when OTel actually reported them, so NULLs are never clobbered with
+ * fabricated values.
+ */
+export class AddCounterSemanticsToMetricType1784191414522
+  implements MigrationInterface
+{
+  public name = "AddCounterSemanticsToMetricType1784191414522";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" ADD "isMonotonic" boolean`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" ADD "aggregationTemporality" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" DROP COLUMN "aggregationTemporality"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "MetricType" DROP COLUMN "isMonotonic"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784191414600-AddViewTypeToMetricSavedView.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * MetricSavedView historically served only the metric LIST page. The
+ * metrics EXPLORER page now mounts its own saved-views control on the
+ * same table, so each row needs to say which surface it belongs to —
+ * otherwise the two controls would cross-list each other's views.
+ *
+ * The column is nullable on purpose: every pre-existing row was created
+ * by the list page, and readers treat NULL as "list". No backfill needed.
+ */
+export class AddViewTypeToMetricSavedView1784191414600
+  implements MigrationInterface
+{
+  public name = "AddViewTypeToMetricSavedView1784191414600";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MetricSavedView" ADD "viewType" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MetricSavedView" DROP COLUMN "viewType"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784211212164-AddNetworkDeviceInventoryAndDiscoverySchedule.ts

@@ -0,0 +1,108 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Generated with generate-postgres-migration, then pruned: the generator
+ * also emitted a DROP + re-ADD of NetworkDeviceDiscoveryScan.snmpV3AuthKey /
+ * snmpV3PrivKey (text -> varchar type churn that would destroy stored keys)
+ * and unrelated OnCallDutyPolicyScheduleLayer default churn. Only the
+ * statements for the new inventory/discovery columns were kept.
+ */
+export class AddNetworkDeviceInventoryAndDiscoverySchedule1784211212164
+  implements MigrationInterface
+{
+  public name = "AddNetworkDeviceInventoryAndDiscoverySchedule1784211212164";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "sysObjectId" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "sysLocation" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "sysContact" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "vendor" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "deviceModel" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "serialNumber" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "firmwareVersion" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "softwareVersion" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "lastRebootedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "cdpNeighbors" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "isRecurring" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "rescanIntervalInMinutes" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "nextScanAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkInterface" ADD "macAddress" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkInterface" ADD "interfaceType" integer`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkInterface" DROP COLUMN "interfaceType"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkInterface" DROP COLUMN "macAddress"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "nextScanAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "rescanIntervalInMinutes"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "isRecurring"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "cdpNeighbors"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "lastRebootedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "softwareVersion"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "firmwareVersion"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "serialNumber"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "deviceModel"`,
+    );
+    await queryRunner.query(`ALTER TABLE "NetworkDevice" DROP COLUMN "vendor"`);
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "sysContact"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "sysLocation"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "sysObjectId"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784218257664-AddEnterpriseLicenseNotificationColumns.ts

@@ -0,0 +1,31 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddEnterpriseLicenseNotificationColumns1784218257664
+  implements MigrationInterface
+{
+  public name: string = "AddEnterpriseLicenseNotificationColumns1784218257664";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseNotificationEmail" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseExpiryReminderDays" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicenseInstance" ADD "masterAdminEmails" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicenseInstance" DROP COLUMN "masterAdminEmails"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseExpiryReminderDays"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseNotificationEmail"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784293516000-AddAttributionColumnsToUserAndProject.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddAttributionColumnsToUserAndProject1784293516000
+  implements MigrationInterface
+{
+  public name: string = "AddAttributionColumnsToUserAndProject1784293516000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "User" ADD "clickIds" jsonb`);
+    await queryRunner.query(
+      `ALTER TABLE "User" ADD "firstTouchAttribution" jsonb`,
+    );
+    await queryRunner.query(`ALTER TABLE "Project" ADD "clickIds" jsonb`);
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "firstTouchAttribution" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" DROP COLUMN "firstTouchAttribution"`,
+    );
+    await queryRunner.query(`ALTER TABLE "Project" DROP COLUMN "clickIds"`);
+    await queryRunner.query(
+      `ALTER TABLE "User" DROP COLUMN "firstTouchAttribution"`,
+    );
+    await queryRunner.query(`ALTER TABLE "User" DROP COLUMN "clickIds"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784298000000-AddMarketingConversionTable.ts

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddMarketingConversionTable1784298000000
+  implements MigrationInterface
+{
+  public name: string = "AddMarketingConversionTable1784298000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "MarketingConversion" ("_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, "conversionType" character varying(100) NOT NULL, "userId" uuid, "projectId" uuid, "email" character varying(100), "clickIds" jsonb NOT NULL, "conversionAt" TIMESTAMP WITH TIME ZONE NOT NULL, "conversionValueInUSDCents" integer, "uploadState" jsonb, CONSTRAINT "PK_MarketingConversion_id" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "idx_marketing_conversion_user_id" ON "MarketingConversion" ("userId")`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "idx_marketing_conversion_project_id" ON "MarketingConversion" ("projectId")`,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "uq_marketing_conversion_type_user" ON "MarketingConversion" ("conversionType", "userId")`,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "uq_marketing_conversion_type_project" ON "MarketingConversion" ("conversionType", "projectId")`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "uq_marketing_conversion_type_project"`,
+    );
+    await queryRunner.query(`DROP INDEX "uq_marketing_conversion_type_user"`);
+    await queryRunner.query(`DROP INDEX "idx_marketing_conversion_project_id"`);
+    await queryRunner.query(`DROP INDEX "idx_marketing_conversion_user_id"`);
+    await queryRunner.query(`DROP TABLE "MarketingConversion"`);
+  }
+}

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

@@ -454,7 +454,13 @@ import { BackfillCodeFixTaskType1784105912819 } from "./1784105912819-BackfillCo
 import { AddAITaskNumberAndRunTranscript1784124919694 } from "./1784124919694-AddAITaskNumberAndRunTranscript";
 import { AllowNullAiAgentOnPullRequest1784135099754 } from "./1784135099754-AllowNullAiAgentOnPullRequest";
 import { AddEnableMcpServerToStatusPage1784137457184 } from "./1784137457184-AddEnableMcpServerToStatusPage";
+import { AddCounterSemanticsToMetricType1784191414522 } from "./1784191414522-AddCounterSemanticsToMetricType";
+import { AddViewTypeToMetricSavedView1784191414600 } from "./1784191414600-AddViewTypeToMetricSavedView";
 import { AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000 } from "./1784200000000-AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan";
+import { AddNetworkDeviceInventoryAndDiscoverySchedule1784211212164 } from "./1784211212164-AddNetworkDeviceInventoryAndDiscoverySchedule";
+import { AddEnterpriseLicenseNotificationColumns1784218257664 } from "./1784218257664-AddEnterpriseLicenseNotificationColumns";
+import { AddAttributionColumnsToUserAndProject1784293516000 } from "./1784293516000-AddAttributionColumnsToUserAndProject";
+import { AddMarketingConversionTable1784298000000 } from "./1784298000000-AddMarketingConversionTable";
 
 export default [
   InitialMigration,
@@ -913,5 +919,11 @@ export default [
   AddAITaskNumberAndRunTranscript1784124919694,
   AllowNullAiAgentOnPullRequest1784135099754,
   AddEnableMcpServerToStatusPage1784137457184,
+  AddCounterSemanticsToMetricType1784191414522,
+  AddViewTypeToMetricSavedView1784191414600,
   AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000,
+  AddNetworkDeviceInventoryAndDiscoverySchedule1784211212164,
+  AddEnterpriseLicenseNotificationColumns1784218257664,
+  AddAttributionColumnsToUserAndProject1784293516000,
+  AddMarketingConversionTable1784298000000,
 ];

package/Server/Services/AnalyticsDatabaseService.ts

@@ -29,7 +29,10 @@ import Select from "../Types/AnalyticsDatabase/Select";
 import UpdateBy from "../Types/AnalyticsDatabase/UpdateBy";
 import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
 import StatementGenerator from "../Utils/AnalyticsDatabase/StatementGenerator";
-import { getQuerySettings } from "../Utils/AnalyticsDatabase/QuerySettingsHelper";
+import {
+  getQuerySettings,
+  TimeoutOverflowMode,
+} from "../Utils/AnalyticsDatabase/QuerySettingsHelper";
 import {
   getStorageTableName,
   onClusterClause,
@@ -892,8 +895,47 @@ export default class AnalyticsDatabaseService<
         aggregatedItems.push(aggregatedModel);
       }
 
+      /*
+       * Top-K statements (see MetricService) carry the pre-trim group
+       * count as a constant `__total_groups` column on every row; lift
+       * it off the first row into result metadata. The per-row copy
+       * loop above only projects timestamp/value/group-by columns, so
+       * the helper column never reaches the rows themselves.
+       */
+      let totalGroups: number | undefined = undefined;
+      const firstItem: JSONObject | undefined = items[0];
+      if (firstItem && firstItem["__total_groups"] !== undefined) {
+        const parsedTotalGroups: number = Number(firstItem["__total_groups"]);
+        if (Number.isFinite(parsedTotalGroups)) {
+          totalGroups = parsedTotalGroups;
+        }
+      }
+
+      /*
+       * Truncation detection. Row-count == LIMIT is a heuristic (an
+       * exactly-full window reads as truncated), but a false positive
+       * only over-warns; the silent-data-loss case it exists to catch
+       * (groups × buckets > limit dropping the oldest buckets) is
+       * always flagged. Top-K truncation is exact: the ranking phase
+       * counted every matching group.
+       */
+      const appliedLimit: number = Number(aggregateBy.limit);
+      let truncated: boolean =
+        Number.isFinite(appliedLimit) &&
+        appliedLimit > 0 &&
+        items.length >= appliedLimit;
+      if (
+        aggregateBy.topK &&
+        totalGroups !== undefined &&
+        totalGroups > aggregateBy.topK.count
+      ) {
+        truncated = true;
+      }
+
       return {
         data: aggregatedItems,
+        ...(totalGroups !== undefined ? { totalGroups } : {}),
+        truncated,
       };
     } catch (error) {
       await this.onFindError(error as Exception);
@@ -1194,6 +1236,24 @@ export default class AnalyticsDatabaseService<
     return statement;
   }
 
+  /**
+   * The timeout_overflow_mode an aggregate statement should carry.
+   * Callers that render charts keep the 'break' default (partial
+   * buckets are acceptable there); callers that ALERT on the result —
+   * the metric-monitor worker — pass 'throw' so a timed-out evaluation
+   * fails loudly instead of silently scoring partial data.
+   *
+   * Allow-listed, never passed through: aggregateBy is deserialized
+   * wholesale from API clients and this setting is emitted into SQL as
+   * a trusted literal (see QuerySettingsHelper), so anything other than
+   * the exact string "throw" degrades to the 'break' default.
+   */
+  protected getTimeoutOverflowMode(
+    aggregateBy: AggregateBy<TBaseModel>,
+  ): TimeoutOverflowMode {
+    return aggregateBy.timeoutOverflowMode === "throw" ? "throw" : "break";
+  }
+
   public toAggregateStatement(aggregateBy: AggregateBy<TBaseModel>): {
     statement: Statement;
     columns: Array<string>;
@@ -1306,6 +1366,13 @@ export default class AnalyticsDatabaseService<
     /*
      * Aggregation read-path settings.
      *
+     * - max_execution_time=45: cap aggregate runtime below the
+     *   ClickHouse client's 58s request_timeout, same as the count/find
+     *   statements — a wide-window aggregate over a large table would
+     *   otherwise run until the HTTP client disconnects. The overflow
+     *   mode defaults to 'break' (partial buckets are acceptable for
+     *   chart rendering) but alerting callers opt into 'throw' via
+     *   aggregateBy.timeoutOverflowMode — see getTimeoutOverflowMode.
      * - optimize_aggregation_in_order: when GROUP BY is a prefix of the
      *   sort key (we always group by a time bucket and the time column
      *   is at the tail of every analytics primary key), ClickHouse can
@@ -1322,6 +1389,8 @@ export default class AnalyticsDatabaseService<
      */
     statement.append(
       getQuerySettings({
+        maxExecutionTimeInSeconds: 45,
+        timeoutOverflowMode: this.getTimeoutOverflowMode(aggregateBy),
         additionalSettings: {
           optimize_aggregation_in_order: 1,
           optimize_move_to_prewhere: 1,

package/Server/Services/IncidentService.ts

@@ -56,6 +56,7 @@ import ServiceType from "../../Types/Telemetry/ServiceType";
 import OneUptimeDate from "../../Types/Date";
 import TelemetryUtil from "../Utils/Telemetry/Telemetry";
 import logger, { LogAttributes } from "../Utils/Logger";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentSlaService from "./IncidentSlaService";
@@ -907,6 +908,18 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("id is required");
     }
 
+    /*
+     * Activation event for marketing funnels. Only fires for human-declared
+     * incidents (captureForUser skips when there is no user).
+     */
+    ProductAnalytics.captureForUser({
+      userId: onCreate.createBy.props.userId || createdItem.createdByUserId,
+      event: "server/incident_created",
+      properties: {
+        project_id: createdItem.projectId.toString(),
+      },
+    });
+
     // Get incident data for feed creation
     const incident: Model | null = await this.findOneById({
       id: createdItem.id,