[v5] chore(web): add dau/wau/mau tracking

packages/db/prisma/migrations/20260526013307_add_user_last_active_at/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "lastActiveAt" TIMESTAMP(3);

packages/db/prisma/schema.prisma

@@ -411,6 +411,9 @@ model User {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
+  /// Last time the user performed an authenticated action.
+  lastActiveAt DateTime?
+
 }
 
 enum AccountPermissionSyncJobStatus {

packages/web/src/ee/features/lighthouse/servicePing.ts

@@ -18,7 +18,19 @@ export const syncWithLighthouse = async (orgId: number) => {
         where: { orgId },
     });
 
-    const [userCount, repoCount] = await Promise.all([
+    const now = Date.now();
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const dauCutoff = new Date(now - 1 * DAY_MS);
+    const wauCutoff = new Date(now - 7 * DAY_MS);
+    const mauCutoff = new Date(now - 30 * DAY_MS);
+
+    const [
+        userCount,
+        repoCount,
+        dauCount,
+        wauCount,
+        mauCount,
+    ] = await Promise.all([
         __unsafePrisma.userToOrg.count({
             where: {
                 orgId,
@@ -29,6 +41,24 @@ export const syncWithLighthouse = async (orgId: number) => {
                 orgId,
             },
         }),
+        __unsafePrisma.user.count({
+            where: {
+                orgs: { some: { orgId } },
+                lastActiveAt: { gte: dauCutoff },
+            },
+        }),
+        __unsafePrisma.user.count({
+            where: {
+                orgs: { some: { orgId } },
+                lastActiveAt: { gte: wauCutoff },
+            },
+        }),
+        __unsafePrisma.user.count({
+            where: {
+                orgs: { some: { orgId } },
+                lastActiveAt: { gte: mauCutoff },
+            },
+        }),
     ]);
 
     const activationCode = license?.activationCode
@@ -40,6 +70,9 @@ export const syncWithLighthouse = async (orgId: number) => {
         version: SOURCEBOT_VERSION,
         userCount,
         repoCount,
+        dauCount,
+        wauCount,
+        mauCount,
         deploymentType: inferDeploymentType(),
         isTelemetryEnabled: env.SOURCEBOT_TELEMETRY_DISABLED === 'false',
         ...(activationCode && { activationCode }),

packages/web/src/ee/features/lighthouse/types.ts

@@ -3,8 +3,11 @@ import { z } from "zod";
 export const servicePingRequestSchema = z.object({
     installId: z.string(),
     version: z.string(),
-    userCount: z.number(),
-    repoCount: z.number(),
+    userCount: z.number().int().nonnegative(),
+    repoCount: z.number().int().nonnegative(),
+    dauCount: z.number().int().nonnegative(),
+    wauCount: z.number().int().nonnegative(),
+    mauCount: z.number().int().nonnegative(),
     deploymentType: z.string(),
     isTelemetryEnabled: z.boolean(),
     activationCode: z.string().optional(),

packages/web/src/middleware/withAuth.ts

@@ -10,6 +10,8 @@ import { ErrorCode } from "../lib/errorCodes";
 import { getOrgMetadata, isServiceError } from "../lib/utils";
 import { hasEntitlement, isAnonymousAccessAvailable } from "@/lib/entitlements";
 
+const LAST_ACTIVE_AT_THRESHOLD_MS = 5 * 60 * 1000;
+
 type RequiredAuthContext = {
     user: UserWithAccounts;
     role: OrgRole;
@@ -107,12 +109,34 @@ export const getAuthContext = async (): Promise<OptionalAuthContext | ServiceErr
 
     const prisma = __unsafePrisma.$extends(await userScopedPrismaClientExtension(user)) as PrismaClient;
 
+    if (user) {
+        updateUserLastActiveAt(user);
+    }
+
     if (user && role) {
         return { user, org, role, prisma };
     }
     return { user, org, prisma };
 };
 
+const updateUserLastActiveAt = (user: UserWithAccounts) => {
+    const now = Date.now();
+    if (
+        user.lastActiveAt &&
+        (now - user.lastActiveAt.getTime()) < LAST_ACTIVE_AT_THRESHOLD_MS
+    ) {
+        return;
+    }
+
+    // Fired without a await to avoid blocking.
+    void __unsafePrisma.user
+        .update({
+            where: { id: user.id },
+            data: { lastActiveAt: new Date(now) },
+        })
+        .catch(() => { /* updaing the lastActiveAt is best effort. */ });
+};
+
 type AuthSource = 'session' | 'oauth' | 'api_key';
 
 export const getAuthenticatedUser = async (): Promise<{ user: UserWithAccounts, source: AuthSource } | undefined> => {