[WEB-5681] refactor: add new event trackers

apps/api/plane/app/serializers/user.py

@@ -78,6 +78,7 @@ class Meta:
             "is_password_autoset",
             "is_email_verified",
             "last_login_medium",
+            "last_login_time",
         ]
         read_only_fields = fields
 

apps/api/plane/app/views/workspace/invite.py

@@ -21,7 +21,7 @@
     WorkSpaceMemberSerializer,
 )
 from plane.app.views.base import BaseAPIView
-from plane.bgtasks.event_tracking_task import workspace_invite_event
+from plane.bgtasks.event_tracking_task import workspace_invite_event, track_event
 from plane.bgtasks.workspace_invitation_task import workspace_invitation
 from plane.db.models import User, Workspace, WorkspaceMember, WorkspaceMemberInvite
 from plane.utils.cache import invalidate_cache, invalidate_cache_directly
@@ -121,6 +121,19 @@ def create(self, request, slug):
                 current_site,
                 request.user.email,
             )
+            track_event.delay(
+                user_id=request.user.id,
+                event_name="user_invited_to_workspace",
+                slug=slug,
+                event_properties={
+                    "user_id": request.user.id,
+                    "workspace_id": workspace.id,
+                    "workspace_slug": workspace.slug,
+                    "invitee_role": invitation.role,
+                    "invited_at": str(timezone.now()),
+                    "invitee_email": invitation.email,
+                },
+            )
 
         return Response({"message": "Emails sent successfully"}, status=status.HTTP_200_OK)
 
@@ -186,20 +199,22 @@ def post(self, request, slug, pk):
                     # Set the user last_workspace_id to the accepted workspace
                     user.last_workspace_id = workspace_invite.workspace.id
                     user.save()
+                    track_event.delay(
+                        user_id=user.id,
+                        event_name="user_joined_workspace",
+                        slug=slug,
+                        event_properties={
+                            "user_id": user.id,
+                            "workspace_id": workspace_invite.workspace.id,
+                            "workspace_slug": workspace_invite.workspace.slug,
+                            "role": workspace_invite.role,
+                            "joined_at": str(timezone.now()),
+                        },
+                    )
 
                     # Delete the invitation
                     workspace_invite.delete()
 
-                # Send event
-                workspace_invite_event.delay(
-                    user=user.id if user is not None else None,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=get_client_ip(request=request),
-                    event_name="MEMBER_ACCEPTED",
-                    accepted_from="EMAIL",
-                )
-
                 return Response(
                     {"message": "Workspace Invitation Accepted"},
                     status=status.HTTP_200_OK,
@@ -252,6 +267,20 @@ def create(self, request):
                 is_active=True, role=invitation.role
             )
 
+            # Track event
+            track_event.delay(
+                user_id=request.user.id,
+                event_name="user_joined_workspace",
+                slug=invitation.workspace.slug,
+                event_properties={
+                    "user_id": request.user.id,
+                    "workspace_id": invitation.workspace.id,
+                    "workspace_slug": invitation.workspace.slug,
+                    "role": invitation.role,
+                    "joined_at": str(timezone.now()),
+                },
+            )
+
         # Bulk create the user for all the workspaces
         WorkspaceMember.objects.bulk_create(
             [

apps/api/plane/authentication/utils/workspace_project_join.py

@@ -1,10 +1,15 @@
+# Django imports
+from django.utils import timezone
+
+# Module imports
 from plane.db.models import (
     ProjectMember,
     ProjectMemberInvite,
     WorkspaceMember,
     WorkspaceMemberInvite,
 )
 from plane.utils.cache import invalidate_cache_directly
+from plane.bgtasks.event_tracking_task import track_event
 
 
 def process_workspace_project_invitations(user):
@@ -25,6 +30,22 @@ def process_workspace_project_invitations(user):
         ignore_conflicts=True,
     )
 
+    [
+        track_event.delay(
+            user_id=user.id,
+            event_name="user_joined_workspaces",
+            slug=workspace_member_invite.workspace.slug,
+            event_properties={
+                "user_id": user.id,
+                "workspace_id": workspace_member_invite.workspace.id,
+                "workspace_slug": workspace_member_invite.workspace.slug,
+                "role": workspace_member_invite.role,
+                "joined_at": str(timezone.now()),
+            },
+        )
+        for workspace_member_invite in workspace_member_invites
+    ]
+
     [
         invalidate_cache_directly(
             path=f"/api/workspaces/{str(workspace_member_invite.workspace.slug)}/members/",

apps/api/plane/bgtasks/event_tracking_task.py

@@ -1,5 +1,7 @@
+import logging
 import os
 import uuid
+from typing import Dict, Any
 
 # third party imports
 from celery import shared_task
@@ -8,45 +10,61 @@
 # module imports
 from plane.license.utils.instance_value import get_configuration_value
 from plane.utils.exception_logger import log_exception
+from plane.db.models import Workspace
+
+
+logger = logging.getLogger("plane.worker")
 
 
 def posthogConfiguration():
-    POSTHOG_API_KEY, POSTHOG_HOST = get_configuration_value(
-        [
-            {
-                "key": "POSTHOG_API_KEY",
-                "default": os.environ.get("POSTHOG_API_KEY", None),
-            },
-            {"key": "POSTHOG_HOST", "default": os.environ.get("POSTHOG_HOST", None)},
-        ]
-    )
+    POSTHOG_API_KEY, POSTHOG_HOST = get_configuration_value([
+        {
+            "key": "POSTHOG_API_KEY",
+            "default": os.environ.get("POSTHOG_API_KEY", None),
+        },
+        {"key": "POSTHOG_HOST", "default": os.environ.get("POSTHOG_HOST", None)},
+    ])
     if POSTHOG_API_KEY and POSTHOG_HOST:
         return POSTHOG_API_KEY, POSTHOG_HOST
     else:
         return None, None
 
 
+def preprocess_data_properties(
+    user_id: uuid.UUID, event_name: str, slug: str, data_properties: Dict[str, Any]
+) -> Dict[str, Any]:
+    if event_name == "user_invited_to_workspace":
+        # Check if the current user is the workspace owner
+        workspace = Workspace.objects.get(slug=slug)
+        if str(workspace.owner_id) == str(user_id):
+            data_properties["role"] = "owner"
+        else:
+            data_properties["role"] = "admin"
+
+    return data_properties
+
+
 @shared_task
-def auth_events(user, email, user_agent, ip, event_name, medium, first_time):
-    try:
-        POSTHOG_API_KEY, POSTHOG_HOST = posthogConfiguration()
+def track_event(user_id: uuid.UUID, event_name: str, slug: str, event_properties: Dict[str, Any]):
+    POSTHOG_API_KEY, POSTHOG_HOST = posthogConfiguration()
 
-        if POSTHOG_API_KEY and POSTHOG_HOST:
-            posthog = Posthog(POSTHOG_API_KEY, host=POSTHOG_HOST)
-            posthog.capture(
-                email,
-                event=event_name,
-                properties={
-                    "event_id": uuid.uuid4().hex,
-                    "user": {"email": email, "id": str(user)},
-                    "device_ctx": {"ip": ip, "user_agent": user_agent},
-                    "medium": medium,
-                    "first_time": first_time,
-                },
-            )
+    if not (POSTHOG_API_KEY and POSTHOG_HOST):
+        logger.warning("Event tracking is not configured")
+        return
+
+    try:
+        # preprocess the data properties for massaging the payload
+        # in the correct format for posthog
+        data_properties = preprocess_data_properties(user_id, event_name, slug, event_properties)
+        groups = {
+            "workspace": slug,
+        }
+        # track the event using posthog
+        posthog = Posthog(POSTHOG_API_KEY, host=POSTHOG_HOST)
+        posthog.capture(distinct_id=user_id, event=event_name, properties=data_properties, groups=groups)
     except Exception as e:
         log_exception(e)
-        return
+        return False
 
 
 @shared_task

apps/web/app/(all)/[workspaceSlug]/(projects)/projects/(detail)/[projectId]/pages/(list)/header.tsx

@@ -1,6 +1,6 @@
-import { useState } from "react";
 import { observer } from "mobx-react";
 import { useParams, useRouter, useSearchParams } from "next/navigation";
+import { useState } from "react";
 // constants
 import { EPageAccess, PROJECT_PAGE_TRACKER_EVENTS, PROJECT_TRACKER_ELEMENTS } from "@plane/constants";
 // plane types
@@ -12,11 +12,14 @@ import type { TPage } from "@plane/types";
 import { Breadcrumbs, Header } from "@plane/ui";
 // helpers
 import { BreadcrumbLink } from "@/components/common/breadcrumb-link";
-import { captureError, captureSuccess } from "@/helpers/event-tracker.helper";
+import { captureError } from "@/helpers/event-tracker.helper";
 // hooks
 import { useProject } from "@/hooks/store/use-project";
 // plane web imports
+import { useWorkspace } from "@/hooks/store/use-workspace";
+import { useUser, useUserPermissions } from "@/hooks/store/user";
 import { CommonProjectBreadcrumbs } from "@/plane-web/components/breadcrumbs/common";
+import { getUserRoleString, trackPageCreated } from "@/plane-web/helpers/event-tracker-v2.helper";
 import { EPageStoreType, usePageStore } from "@/plane-web/hooks/store";
 
 export const PagesListHeader = observer(function PagesListHeader() {
@@ -28,42 +31,54 @@ export const PagesListHeader = observer(function PagesListHeader() {
   const searchParams = useSearchParams();
   const pageType = searchParams.get("type");
   // store hooks
+  const { getWorkspaceRoleByWorkspaceSlug } = useUserPermissions();
+  const { data: currentUser } = useUser();
+  const { currentWorkspace } = useWorkspace();
   const { currentProjectDetails, loader } = useProject();
   const { canCurrentUserCreatePage, createPage } = usePageStore(EPageStoreType.PROJECT);
   // handle page create
   const handleCreatePage = async () => {
-    setIsCreatingPage(true);
+    try {
+      setIsCreatingPage(true);
 
-    const payload: Partial<TPage> = {
-      access: pageType === "private" ? EPageAccess.PRIVATE : EPageAccess.PUBLIC,
-    };
+      const payload: Partial<TPage> = {
+        access: pageType === "private" ? EPageAccess.PRIVATE : EPageAccess.PUBLIC,
+      };
 
-    await createPage(payload)
-      .then((res) => {
-        captureSuccess({
-          eventName: PROJECT_PAGE_TRACKER_EVENTS.create,
-          payload: {
-            id: res?.id,
-            state: "SUCCESS",
-          },
-        });
-        const pageId = `/${workspaceSlug}/projects/${currentProjectDetails?.id}/pages/${res?.id}`;
-        router.push(pageId);
-      })
-      .catch((err) => {
-        captureError({
-          eventName: PROJECT_PAGE_TRACKER_EVENTS.create,
-          payload: {
-            state: "ERROR",
+      const pageData = await createPage(payload);
+      if (!pageData?.id) throw new Error("Invalid response");
+      if (currentWorkspace && currentUser) {
+        const role = getWorkspaceRoleByWorkspaceSlug(currentWorkspace.slug);
+        trackPageCreated(
+          {
+            id: pageData.id,
+            project_id: projectId,
+            created_at: pageData.created_at ?? "",
           },
-        });
-        setToast({
-          type: TOAST_TYPE.ERROR,
-          title: "Error!",
-          message: err?.data?.error || "Page could not be created. Please try again.",
-        });
-      })
-      .finally(() => setIsCreatingPage(false));
+          currentWorkspace,
+          currentUser,
+          "project",
+          getUserRoleString(role)
+        );
+      }
+      const pageId = `/${workspaceSlug}/projects/${currentProjectDetails?.id}/pages/${pageData.id}`;
+      router.push(pageId);
+    } catch (err: any) {
+      captureError({
+        eventName: PROJECT_PAGE_TRACKER_EVENTS.create,
+        payload: {
+          state: "ERROR",
+          error: err?.data?.error,
+        },
+      });
+      setToast({
+        type: TOAST_TYPE.ERROR,
+        title: "Error!",
+        message: err?.data?.error || "Page could not be created. Please try again.",
+      });
+    } finally {
+      setIsCreatingPage(false);
+    }
   };
 
   return (

apps/web/app/(all)/invitations/page.tsx

@@ -29,6 +29,7 @@ import { useAppRouter } from "@/hooks/use-app-router";
 import { AuthenticationWrapper } from "@/lib/wrappers/authentication-wrapper";
 // plane web services
 import { WorkspaceService } from "@/plane-web/services";
+import { joinWorkspaceGroup } from "@/plane-web/helpers/event-tracker-v2.helper";
 
 const workspaceService = new WorkspaceService();
 
@@ -80,10 +81,9 @@ function UserInvitationsPage() {
         const invitation = invitations?.find((i) => i.id === firstInviteId);
         const redirectWorkspace = invitations?.find((i) => i.id === firstInviteId)?.workspace;
         if (redirectWorkspace?.id) {
-          joinEventGroup(GROUP_WORKSPACE_TRACKER_EVENT, redirectWorkspace?.id, {
-            date: new Date().toDateString(),
-            workspace_id: redirectWorkspace?.id,
-          });
+          if (redirectWorkspace) {
+            joinWorkspaceGroup(redirectWorkspace);
+          }
         }
         captureSuccess({
           eventName: MEMBER_TRACKER_EVENTS.accept,