@oneuptime/common 11.5.8 → 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({
@@ -2144,6 +2280,48 @@ export class ProjectService extends DatabaseService<Model> {
     }
   }
 
+  /*
+   * Allocate the next AI task number for a project. Unlike the counters
+   * above there is no companion prefix column — AI task numbers are not
+   * user-customizable, so the caller renders a plain "#N".
+   */
+  @CaptureSpan()
+  public async incrementAndGetAIRunCounter(
+    projectId: ObjectID,
+  ): Promise<number> {
+    const mutex: SemaphoreMutex = await Semaphore.lock({
+      key: projectId.toString(),
+      namespace: "ProjectService.aiRunCounter",
+    });
+
+    try {
+      await this.atomicIncrementColumnValueByOne({
+        id: projectId,
+        columnName: "aiRunCounter",
+      });
+
+      const project: Model | null = await this.findOneById({
+        id: projectId,
+        select: {
+          aiRunCounter: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!project || project.aiRunCounter === undefined) {
+        throw new BadDataException(
+          `Could not read aiRunCounter for project ${projectId.toString()}`,
+        );
+      }
+
+      return project.aiRunCounter;
+    } finally {
+      await Semaphore.release(mutex);
+    }
+  }
+
   @CaptureSpan()
   public async isSMSNotificationsEnabled(
     projectId: ObjectID,

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";
@@ -118,6 +119,93 @@ export class Service extends DatabaseService<StatusPage> {
     this.statusPageUrlCache.clear();
   }
 
+  /*
+   * Mirrors `resolveStatusPageIdOrThrow` in `Common/Server/API/StatusPageAPI.ts`
+   * (module-private there), but returns null instead of throwing so callers can
+   * collapse "no such page" and "page exists but is gated" into one answer.
+   * The dot check — not a UUID check — is the discriminator, so both resolvers
+   * agree on dotless hostnames like "localhost".
+   */
+  @CaptureSpan()
+  public async resolveStatusPageIdOrNull(
+    statusPageIdOrDomain: string,
+  ): Promise<ObjectID | null> {
+    if (!statusPageIdOrDomain) {
+      return null;
+    }
+
+    if (statusPageIdOrDomain.includes(".")) {
+      const statusPageDomain: StatusPageDomain | null =
+        await StatusPageDomainService.findOneBy({
+          query: {
+            fullDomain: statusPageIdOrDomain,
+            domain: {
+              isVerified: true,
+            } as any,
+          },
+          select: {
+            statusPageId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!statusPageDomain || !statusPageDomain.statusPageId) {
+        return null;
+      }
+
+      return statusPageDomain.statusPageId;
+    }
+
+    try {
+      ObjectID.validateUUID(statusPageIdOrDomain);
+      return new ObjectID(statusPageIdOrDomain);
+    } catch (err) {
+      logger.error(
+        `Error converting statusPageIdOrDomain to ObjectID: ${statusPageIdOrDomain}`,
+      );
+      logger.error(err);
+      return null;
+    }
+  }
+
+  /*
+   * Folds existence and the `enableMcpServer` flag into a single query so the
+   * caller cannot distinguish "not found" from "disabled". The public MCP tools
+   * need no API key, so a distinct "disabled" message would be a status page
+   * enumeration oracle.
+   *
+   * Throws on database failure rather than returning false, so the caller
+   * reports an error instead of reporting the page as gated.
+   */
+  @CaptureSpan()
+  public async isMcpServerEnabled(
+    statusPageIdOrDomain: string,
+  ): Promise<boolean> {
+    const statusPageId: ObjectID | null =
+      await this.resolveStatusPageIdOrNull(statusPageIdOrDomain);
+
+    if (!statusPageId) {
+      return false;
+    }
+
+    const statusPage: StatusPage | null = await this.findOneBy({
+      query: {
+        _id: statusPageId,
+        enableMcpServer: true,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return Boolean(statusPage);
+  }
+
   public static getDefaultEmailFooterText(): string {
     return "This is an automated email sent to you because you are subscribed to this Status Page.";
   }
@@ -227,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;
   }