@oneuptime/common 11.5.9 → 11.5.10

package/Server/Services/MonitorService.ts

@@ -68,6 +68,7 @@ import { MonitorFeedEventType } from "../../Models/DatabaseModels/MonitorFeed";
 import { Gray500, Green500 } from "../../Types/BrandColors";
 import LabelService from "./LabelService";
 import logger, { LogAttributes } from "../Utils/Logger";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import PushNotificationUtil from "../Utils/PushNotificationUtil";
 import ExceptionMessages from "../../Types/Exception/ExceptionMessages";
 import Project from "../../Models/DatabaseModels/Project";
@@ -637,6 +638,19 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("currentMonitorStatusId is required");
     }
 
+    /*
+     * Activation event for marketing funnels. Only fires for human-created
+     * monitors (captureForUser skips when there is no user).
+     */
+    ProductAnalytics.captureForUser({
+      userId: onCreate.createBy.props.userId || createdItem.createdByUserId,
+      event: "server/monitor_created",
+      properties: {
+        project_id: createdItem.projectId.toString(),
+        monitor_type: createdItem.monitorType?.toString() || "",
+      },
+    });
+
     const monitor: Model | null = await this.findOneById({
       id: createdItem.id,
       select: {

package/Server/Services/NetworkDeviceOwnerTeamService.ts

@@ -1,10 +1,52 @@
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/NetworkDeviceOwnerTeam";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * Returns the ids of all teams that own the given network device. Used to
+   * fan device ownership into monitor-created incidents/alerts and into the
+   * owner-added notification job.
+   */
+  @CaptureSpan()
+  public async getOwnerTeamIdsForDevice(
+    networkDeviceId: ObjectID,
+    projectId?: ObjectID | undefined,
+  ): Promise<Array<ObjectID>> {
+    const ownerTeams: Array<Model> = await this.findBy({
+      query: {
+        networkDeviceId: networkDeviceId,
+        /*
+         * Scope to the project when known so a monitor step referencing a
+         * device from another project can never fan out its owners.
+         */
+        ...(projectId ? { projectId: projectId } : {}),
+      },
+      select: {
+        _id: true,
+        teamId: true,
+      },
+      skip: 0,
+      limit: LIMIT_PER_PROJECT,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return ownerTeams
+      .map((ownerTeam: Model) => {
+        return ownerTeam.teamId!;
+      })
+      .filter((teamId: ObjectID) => {
+        return Boolean(teamId);
+      });
+  }
 }
 
 export default new Service();

package/Server/Services/NetworkDeviceOwnerUserService.ts

@@ -1,10 +1,116 @@
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import MonitorStep from "../../Types/Monitor/MonitorStep";
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
+import NetworkDeviceOwnerTeamService from "./NetworkDeviceOwnerTeamService";
 import Model from "../../Models/DatabaseModels/NetworkDeviceOwnerUser";
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export interface NetworkDeviceOwners {
+  ownerUserIds: Array<ObjectID>;
+  ownerTeamIds: Array<ObjectID>;
+}
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * Returns the ids of all users that own the given network device. Used to
+   * fan device ownership into monitor-created incidents/alerts and into the
+   * owner-added notification job.
+   */
+  @CaptureSpan()
+  public async getOwnerUserIdsForDevice(
+    networkDeviceId: ObjectID,
+    projectId?: ObjectID | undefined,
+  ): Promise<Array<ObjectID>> {
+    const ownerUsers: Array<Model> = await this.findBy({
+      query: {
+        networkDeviceId: networkDeviceId,
+        /*
+         * Scope to the project when known so a monitor step referencing a
+         * device from another project can never fan out its owners.
+         */
+        ...(projectId ? { projectId: projectId } : {}),
+      },
+      select: {
+        _id: true,
+        userId: true,
+      },
+      skip: 0,
+      limit: LIMIT_PER_PROJECT,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return ownerUsers
+      .map((ownerUser: Model) => {
+        return ownerUser.userId!;
+      })
+      .filter((userId: ObjectID) => {
+        return Boolean(userId);
+      });
+  }
+
+  /*
+   * Resolves the owner users/teams of the network device a monitor watches
+   * (if any). The device id lives on the monitor step config
+   * (step.data.networkDeviceMonitor.networkDeviceId). Prefer the step that
+   * produced the current probe response; fall back to the first step that
+   * references a device so callers without a step id still pick up owners.
+   * No-op (and no queries) for monitors that do not reference a device.
+   */
+  @CaptureSpan()
+  public async getDeviceOwnersForMonitor(data: {
+    monitor: Monitor;
+    monitorStepId?: string | undefined;
+  }): Promise<NetworkDeviceOwners> {
+    const monitorSteps: Array<MonitorStep> =
+      data.monitor.monitorSteps?.data?.monitorStepsInstanceArray || [];
+
+    let monitorStep: MonitorStep | undefined = undefined;
+
+    if (data.monitorStepId) {
+      monitorStep = monitorSteps.find((step: MonitorStep) => {
+        return step.id.toString() === data.monitorStepId;
+      });
+    }
+
+    if (!monitorStep?.data?.networkDeviceMonitor?.networkDeviceId) {
+      monitorStep = monitorSteps.find((step: MonitorStep) => {
+        return Boolean(step.data?.networkDeviceMonitor?.networkDeviceId);
+      });
+    }
+
+    const networkDeviceIdAsString: string | undefined =
+      monitorStep?.data?.networkDeviceMonitor?.networkDeviceId;
+
+    if (!networkDeviceIdAsString) {
+      return {
+        ownerUserIds: [],
+        ownerTeamIds: [],
+      };
+    }
+
+    const networkDeviceId: ObjectID = new ObjectID(networkDeviceIdAsString);
+    const projectId: ObjectID | undefined = data.monitor.projectId;
+
+    return {
+      ownerUserIds: await this.getOwnerUserIdsForDevice(
+        networkDeviceId,
+        projectId,
+      ),
+      ownerTeamIds:
+        await NetworkDeviceOwnerTeamService.getOwnerTeamIdsForDevice(
+          networkDeviceId,
+          projectId,
+        ),
+    };
+  }
 }
 
 export default new Service();

package/Server/Services/NetworkFlowService.ts

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

package/Server/Services/OnCallDutyPolicyService.ts

@@ -31,6 +31,7 @@ import WorkspaceNotificationRuleService, {
   MessageBlocksByWorkspaceType,
 } from "./WorkspaceNotificationRuleService";
 import logger, { LogAttributes } from "../Utils/Logger";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import OnCallDutyPolicyWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/OnCallDutyPolicy";
 import OnCallDutyPolicyFeedService from "./OnCallDutyPolicyFeedService";
 import { OnCallDutyPolicyFeedEventType } from "../../Models/DatabaseModels/OnCallDutyPolicyFeed";
@@ -44,13 +45,22 @@ export class Service extends DatabaseService<OnCallDutyPolicy> {
   }
 
   protected override async onCreateSuccess(
-    _onCreate: OnCreate<OnCallDutyPolicy>,
+    onCreate: OnCreate<OnCallDutyPolicy>,
     createdItem: OnCallDutyPolicy,
   ): Promise<OnCallDutyPolicy> {
     if (!createdItem.id) {
       throw new BadDataException("On Call Policy id not found.");
     }
 
+    // Activation event for marketing funnels.
+    ProductAnalytics.captureForUser({
+      userId: onCreate.createBy.props.userId || createdItem.createdByUserId,
+      event: "server/on_call_policy_created",
+      properties: {
+        project_id: createdItem.projectId?.toString() || "",
+      },
+    });
+
     if (createdItem.projectId) {
       try {
         await OnCallDutyPolicyLabelRuleEngineService.applyRulesToOnCallDutyPolicy(

package/Server/Services/ProjectService.ts

@@ -15,6 +15,7 @@ import QueryHelper from "../Types/Database/QueryHelper";
 import UpdateBy from "../Types/Database/UpdateBy";
 import logger, { LogAttributes } from "../Utils/Logger";
 import Errors from "../Utils/Errors";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import AccessTokenService from "./AccessTokenService";
 import BillingService from "./BillingService";
 import DatabaseService from "./DatabaseService";
@@ -55,6 +56,7 @@ import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import IconProp from "../../Types/Icon/IconProp";
+import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
@@ -169,6 +171,8 @@ export class ProjectService extends DatabaseService<Model> {
         utmTerm: true,
         utmContent: true,
         utmUrl: true,
+        clickIds: true,
+        firstTouchAttribution: true,
       },
       props: {
         isRoot: true,
@@ -324,6 +328,10 @@ export class ProjectService extends DatabaseService<Model> {
     data.data.utmContent = user.utmContent!;
     data.data.utmUrl = user.utmUrl!;
 
+    // Ad attribution info (click IDs + first touch).
+    data.data.clickIds = user.clickIds!;
+    data.data.firstTouchAttribution = user.firstTouchAttribution!;
+
     // Set default number prefixes.
     if (!data.data.incidentNumberPrefix) {
       data.data.incidentNumberPrefix = "INC-";
@@ -477,6 +485,11 @@ export class ProjectService extends DatabaseService<Model> {
         paymentProviderPlanId: true,
         trialEndsAt: true,
         paymentProviderCustomerId: true,
+        createdOwnerEmail: true,
+        utmSource: true,
+        utmMedium: true,
+        utmCampaign: true,
+        clickIds: true,
       },
       props: {
         isRoot: true,
@@ -583,9 +596,116 @@ export class ProjectService extends DatabaseService<Model> {
       },
     });
 
+    this.capturePlanChangeAnalytics({
+      project: project,
+      newPlan: plan,
+      newPlanId: params.paymentProviderPlanId,
+      seats: seats,
+    });
+
     await this.sendSubscriptionChangeWebhookSlackNotification(project.id!);
   }
 
+  /*
+   * The paid-conversion event for ad platforms: fires server-side (immune to
+   * ad blockers) whenever a project's subscription plan changes, with enough
+   * detail (plan amounts, attribution) for revenue reporting and offline
+   * conversion uploads.
+   *
+   * Upgrade/downgrade is classified by plan tier (getPlanOrder), not price:
+   * monthly<->yearly switches of the same tier and custom-pricing plans
+   * (amount sentinel -1) would misclassify on price comparison.
+   */
+  private capturePlanChangeAnalytics(data: {
+    project: Model;
+    newPlan: SubscriptionPlan;
+    newPlanId: string;
+    seats: number;
+  }): void {
+    if (!data.project.createdOwnerEmail) {
+      return;
+    }
+
+    const oldPlanId: string | undefined =
+      data.project.paymentProviderPlanId || undefined;
+
+    // Re-submitting the currently active plan is a no-op, not a plan change.
+    if (oldPlanId === data.newPlanId) {
+      return;
+    }
+
+    const oldPlan: SubscriptionPlan | undefined = oldPlanId
+      ? SubscriptionPlan.getSubscriptionPlanById(oldPlanId, getAllEnvVars())
+      : undefined;
+
+    // Per-month amount, or null when unknown (custom pricing / unknown plan).
+    const getMonthlyAmountInUSD: (
+      plan: SubscriptionPlan | undefined,
+      planId: string | undefined,
+    ) => number | null = (
+      plan: SubscriptionPlan | undefined,
+      planId: string | undefined,
+    ): number | null => {
+      if (!plan || !planId || plan.isCustomPricing()) {
+        return null;
+      }
+      return plan.getYearlyPlanId() === planId
+        ? plan.getYearlySubscriptionAmountInUSD()
+        : plan.getMonthlySubscriptionAmountInUSD();
+    };
+
+    const oldMonthlyAmountInUSD: number | null = getMonthlyAmountInUSD(
+      oldPlan,
+      oldPlanId,
+    );
+    const newMonthlyAmountInUSD: number | null = getMonthlyAmountInUSD(
+      data.newPlan,
+      data.newPlanId,
+    );
+
+    const oldPlanOrder: number | null = oldPlan ? oldPlan.getPlanOrder() : null;
+    const newPlanOrder: number = data.newPlan.getPlanOrder();
+
+    const newPlanIsPaid: boolean =
+      data.newPlan.isCustomPricing() ||
+      (newMonthlyAmountInUSD !== null && newMonthlyAmountInUSD > 0);
+
+    const properties: JSONObject = {
+      project_id: data.project.id?.toString() || "",
+      old_plan: oldPlan?.getName() || "",
+      new_plan: data.newPlan.getName(),
+      seats: data.seats,
+      is_upgrade: oldPlanOrder !== null && newPlanOrder > oldPlanOrder,
+      is_downgrade: oldPlanOrder !== null && newPlanOrder < oldPlanOrder,
+      // Same tier, different plan id: monthly<->yearly billing switch.
+      is_interval_change:
+        oldPlanOrder !== null && newPlanOrder === oldPlanOrder,
+      is_paid_conversion: oldMonthlyAmountInUSD === 0 && newPlanIsPaid,
+      has_custom_pricing: data.newPlan.isCustomPricing(),
+      utm_source: data.project.utmSource || "",
+      utm_medium: data.project.utmMedium || "",
+      utm_campaign: data.project.utmCampaign || "",
+      click_ids: data.project.clickIds || {},
+    };
+
+    if (oldMonthlyAmountInUSD !== null) {
+      properties["old_monthly_amount_in_usd"] = oldMonthlyAmountInUSD;
+    }
+
+    if (newMonthlyAmountInUSD !== null) {
+      properties["new_monthly_amount_in_usd"] = newMonthlyAmountInUSD;
+      // Value for ROAS reporting: monthly recurring revenue after the change.
+      properties["value"] = newMonthlyAmountInUSD * data.seats;
+      properties["currency"] = "USD";
+    }
+
+    ProductAnalytics.capture({
+      event: "server/subscription_plan_changed",
+      distinctId: data.project.createdOwnerEmail.toString(),
+      properties: properties,
+    });
+  }
+
   private async sendSubscriptionChangeWebhookSlackNotification(
     projectId: ObjectID,
   ): Promise<void> {
@@ -858,6 +978,22 @@ export class ProjectService extends DatabaseService<Model> {
       this.addDefaultIncidentRoles(createdItem),
     ]);
 
+    if (createdItem.createdOwnerEmail) {
+      ProductAnalytics.capture({
+        event: "server/project_created",
+        distinctId: createdItem.createdOwnerEmail.toString(),
+        properties: {
+          project_id: createdItem.id?.toString() || "",
+          project_name: createdItem.name?.toString() || "",
+          plan: createdItem.planName?.toString() || "",
+          utm_source: createdItem.utmSource || "",
+          utm_medium: createdItem.utmMedium || "",
+          utm_campaign: createdItem.utmCampaign || "",
+          click_ids: createdItem.clickIds || {},
+        },
+      });
+    }
+
     if (NotificationSlackWebhookOnCreateProject) {
       // fetch project again.
       const project: Model | null = await this.findOneById({

package/Server/Services/SpanService.ts

@@ -8,6 +8,7 @@ import AggregateBy, {
 import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
 import { getQuerySettings } from "../Utils/AnalyticsDatabase/QuerySettingsHelper";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+import AggregationInterval from "../../Types/BaseDatabase/AggregationInterval";
 import AggregationType from "../../Types/BaseDatabase/AggregationType";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import InBetween from "../../Types/BaseDatabase/InBetween";
@@ -340,20 +341,23 @@ export class SpanService extends AnalyticsDatabaseService<Span> {
     }
     const databaseName: string = this.database.getDatasourceOptions().database!;
 
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp,
-      endDate: aggregateBy.endTimestamp,
-    }).toLowerCase();
+    const aggregationInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp,
+        endDate: aggregateBy.endTimestamp,
+      });
 
     /*
-     * Bucket expression derived from the projection key: for the minute
-     * interval date_trunc is a no-op, for coarser intervals truncating
-     * the minute equals truncating the raw timestamp. Aliased to the
-     * timestamp column name so the generic result parsing applies.
+     * Bucket expression derived from the projection key via the shared
+     * interval-expression map (the sub-hour tiers are not valid
+     * date_trunc units): bucketing the minute-truncated timestamp
+     * equals bucketing the raw timestamp for every interval >= 1
+     * minute. Aliased to the timestamp column name so the generic
+     * result parsing applies.
      */
     const statement: Statement = new Statement();
     statement.append(
-      `SELECT ${aggregateExpression} as durationUnixNano, date_trunc('${aggregationInterval}', toStartOfMinute(startTime)) as startTime`,
+      `SELECT ${aggregateExpression} as durationUnixNano, ${AggregateUtil.buildBucketTimestampExpression(aggregationInterval, "toStartOfMinute(startTime)")} as startTime`,
     );
     statement.append(
       SQL` FROM ${databaseName}.${this.model.tableName} WHERE projectId = ${{

package/Server/Services/StatusPageService.ts

@@ -7,6 +7,7 @@ import CookieUtil from "../Utils/Cookie";
 import { ExpressRequest } from "../Utils/Express";
 import JSONWebToken from "../Utils/JsonWebToken";
 import logger, { LogAttributes } from "../Utils/Logger";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import DatabaseService from "./DatabaseService";
 import MonitorStatusService from "./MonitorStatusService";
@@ -314,6 +315,15 @@ export class Service extends DatabaseService<StatusPage> {
     onCreate: OnCreate<StatusPage>,
     createdItem: StatusPage,
   ): Promise<StatusPage> {
+    // Activation event for marketing funnels.
+    ProductAnalytics.captureForUser({
+      userId: onCreate.createBy.props.userId || createdItem.createdByUserId,
+      event: "server/status_page_created",
+      properties: {
+        project_id: createdItem.projectId?.toString() || "",
+      },
+    });
+
     // Execute owner assignment asynchronously
     if (
       createdItem.projectId &&

package/Server/Services/TeamMemberService.ts

@@ -9,6 +9,7 @@ import Select from "../Types/Database/Select";
 import UpdateBy from "../Types/Database/UpdateBy";
 import Errors from "../Utils/Errors";
 import logger, { LogAttributes } from "../Utils/Logger";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import AccessTokenService from "./AccessTokenService";
 import BillingService from "./BillingService";
 import DatabaseService from "./DatabaseService";
@@ -296,6 +297,16 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
       onCreate.createBy.data.projectId!,
     );
 
+    // Activation event for marketing funnels, attributed to the inviter.
+    ProductAnalytics.captureForUser({
+      userId: onCreate.createBy.props.userId,
+      event: "server/team_member_invited",
+      properties: {
+        project_id: onCreate.createBy.data.projectId?.toString() || "",
+        has_accepted_invitation: Boolean(createdItem.hasAcceptedInvitation),
+      },
+    });
+
     return createdItem;
   }
 

package/Server/Services/UserService.ts

@@ -4,8 +4,10 @@ import {
   NotificationSlackWebhookOnCreateUser,
 } from "../EnvironmentConfig";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
 import UpdateBy from "../Types/Database/UpdateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
+import Attribution from "../Utils/Attribution";
 import logger, { LogAttributes } from "../Utils/Logger";
 import DatabaseService from "./DatabaseService";
 import EmailVerificationTokenService from "./EmailVerificationTokenService";
@@ -25,12 +27,14 @@ import OneUptimeDate from "../../Types/Date";
 import Email from "../../Types/Email";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import HashedString from "../../Types/HashedString";
+import { JSONObject, JSONValue } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import Text from "../../Types/Text";
 import EmailVerificationToken from "../../Models/DatabaseModels/EmailVerificationToken";
 import TeamMember from "../../Models/DatabaseModels/TeamMember";
 import Model from "../../Models/DatabaseModels/User";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import UserTotpAuth from "../../Models/DatabaseModels/UserTotpAuth";
 import UserTotpAuthService from "./UserTotpAuthService";
 import UserWebAuthn from "../../Models/DatabaseModels/UserWebAuthn";
@@ -120,6 +124,38 @@ export class Service extends DatabaseService<Model> {
     );
   }
 
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    /*
+     * clickIds / firstTouchAttribution are publicly creatable jsonb columns
+     * (set during signup). Unlike the varchar(500) utm columns they have no
+     * DB-level size bound, so whitelist keys and cap value lengths here.
+     */
+    const sanitizedClickIds: JSONObject | undefined =
+      Attribution.sanitizeClickIds(createBy.data.clickIds as JSONValue);
+
+    if (sanitizedClickIds) {
+      createBy.data.clickIds = sanitizedClickIds;
+    } else {
+      delete createBy.data.clickIds;
+    }
+
+    const sanitizedFirstTouchAttribution: JSONObject | undefined =
+      Attribution.sanitizeFirstTouchAttribution(
+        createBy.data.firstTouchAttribution as JSONValue,
+      );
+
+    if (sanitizedFirstTouchAttribution) {
+      createBy.data.firstTouchAttribution = sanitizedFirstTouchAttribution;
+    } else {
+      delete createBy.data.firstTouchAttribution;
+    }
+
+    return { createBy, carryForward: null };
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
@@ -141,6 +177,29 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    /*
+     * Server-side signup event (ad blockers eat the client-side one). Also
+     * fires for users created via team invites — has_password separates
+     * direct signups (true) from invited users (false).
+     */
+    if (createdItem.email) {
+      ProductAnalytics.capture({
+        event: "server/user_created",
+        distinctId: createdItem.email.toString(),
+        properties: {
+          has_password: Boolean(createdItem.password),
+          utm_source: createdItem.utmSource || "",
+          utm_medium: createdItem.utmMedium || "",
+          utm_campaign: createdItem.utmCampaign || "",
+          utm_term: createdItem.utmTerm || "",
+          utm_content: createdItem.utmContent || "",
+          utm_url: createdItem.utmUrl || "",
+          click_ids: createdItem.clickIds || {},
+          first_touch: createdItem.firstTouchAttribution || {},
+        },
+      });
+    }
+
     // A place holder method used for overriding.
     return Promise.resolve(createdItem);
   }

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -38,19 +38,50 @@ export class AggregateUtil {
     return interval === AggregationInterval.Total;
   }
 
+  /**
+   * The single source of truth for "which ClickHouse expression buckets
+   * a timestamp at this interval". Every aggregate SQL builder (raw
+   * table, minute MV, per-host MV, span projections) must go through
+   * this instead of lowercasing the enum value into the statement:
+   * the calendar units happen to double as SQL unit names
+   * (`date_trunc('hour', ...)`), but the sub-hour tiers
+   * (FiveMinutes/...) are not valid units and compile to
+   * `toStartOfInterval(col, INTERVAL 5 MINUTE)` instead — which
+   * ClickHouse counts in whole intervals since the epoch, so the
+   * 5/15/30-minute grids are exact on the client's epoch-ms grid too.
+   *
+   * `timestampExpression` is a model-validated identifier or a builder-
+   * owned expression, so raw interpolation here is consistent with the
+   * surrounding builders. `Total` has no bucket expression (the window
+   * collapses into `min(col)` — see buildBucketTimestampSelect).
+   */
+  public static buildBucketTimestampExpression(
+    resolvedInterval: AggregationInterval,
+    timestampExpression: string,
+  ): string {
+    switch (resolvedInterval) {
+      case AggregationInterval.FiveMinutes:
+        return `toStartOfInterval(${timestampExpression}, INTERVAL 5 MINUTE)`;
+      case AggregationInterval.FifteenMinutes:
+        return `toStartOfInterval(${timestampExpression}, INTERVAL 15 MINUTE)`;
+      case AggregationInterval.ThirtyMinutes:
+        return `toStartOfInterval(${timestampExpression}, INTERVAL 30 MINUTE)`;
+      default: {
+        const interval: string = resolvedInterval.toLowerCase();
+        return `date_trunc('${interval}', toStartOfInterval(${timestampExpression}, INTERVAL 1 ${interval}))`;
+      }
+    }
+  }
+
   /**
    * The SELECT fragment that produces the bucket timestamp column,
    * already aliased to `timestampColumn`. Shared by every aggregate SQL
    * builder so the `Total` (whole-window) shape stays identical across
    * paths:
    *
-   *   - normal interval → `date_trunc('<i>', toStartOfInterval(col, INTERVAL 1 <i>)) as col`
+   *   - normal interval → buildBucketTimestampExpression(...) `as col`
    *   - Total           → `min(col) as col` (one row per group; the
    *     earliest sample timestamp in the window is the bucket label)
-   *
-   * `timestampColumn` is a model-validated identifier (see
-   * AnalyticsDatabaseService._aggregateBy), so raw interpolation here is
-   * consistent with the surrounding builders.
    */
   public static buildBucketTimestampSelect(
     resolvedInterval: AggregationInterval,
@@ -60,7 +91,6 @@ export class AggregateUtil {
       return `min(${timestampColumn}) as ${timestampColumn}`;
     }
 
-    const interval: string = resolvedInterval.toLowerCase();
-    return `date_trunc('${interval}', toStartOfInterval(${timestampColumn}, INTERVAL 1 ${interval})) as ${timestampColumn}`;
+    return `${AggregateUtil.buildBucketTimestampExpression(resolvedInterval, timestampColumn)} as ${timestampColumn}`;
   }
 }