🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
import { env } from "@/src/env.mjs";
import { prisma, Role } from "@langfuse/shared/src/db";
import { logger } from "@langfuse/shared/src/server";
import { ServerPosthog } from "@/src/features/posthog-analytics/ServerPosthog";
import { getOrganizationPlanServerSide } from "@/src/features/entitlements/server/getPlan";
import { hasEntitlementBasedOnPlan } from "@/src/features/entitlements/server/hasEntitlement";
import { shouldAutoEnableV4 } from "@/src/features/events/lib/v4Rollout";
import { getSfdcService } from "@/src/ee/features/sfdc-sync/server/sfdcService";
import { canCreateOrganizations } from "@/src/features/organizations/server/canCreateOrganizations";
import { provisionStarterOrganizationForNewUser } from "@/src/features/onboarding/server/onboardingService";
import { isGatewayEnabledForOrganization } from "@/src/features/ai-gateway/server/availability";
import { projectRoleAccessRights } from "@langfuse/shared";
import { type AdClickIds } from "@/src/features/auth/lib/signupAttribution";
export async function createProjectMembershipsOnSignup(
user: {
id: string;
email: string | null;
name: string | null;
},
options?: {
userWasJustCreated?: boolean;
/** Ad-platform click ids, see getAdClickIdsFromRequest */
adClickIds?: AdClickIds;
},
) {
try {
const isCloudDeployment = Boolean(env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION);
// in no case do we want to send duplicate sign up events to posthog
const isNewUser = !(await prisma.organizationMembership.findFirst({
where: { userId: user.id },
select: { id: true },
}));
// Langfuse Cloud: provide view-only access to the demo project, none access to the demo org
const demoProject =
env.NEXT_PUBLIC_DEMO_ORG_ID && env.NEXT_PUBLIC_DEMO_PROJECT_ID
? ((await prisma.project.findUnique({
where: {
orgId: env.NEXT_PUBLIC_DEMO_ORG_ID,
id: env.NEXT_PUBLIC_DEMO_PROJECT_ID,
},
})) ?? undefined)
: undefined;
if (demoProject !== undefined) {
await prisma.organizationMembership.upsert({
where: {
orgId_userId: { orgId: demoProject.orgId, userId: user.id },
},
update: {}, // No-op: preserve existing role
create: {
userId: user.id,
orgId: demoProject.orgId,
role: Role.VIEWER,
},
});
}
// self-hosted: LANGFUSE_DEFAULT_ORG_ID (supports comma-separated list of org IDs)
const defaultOrgIds = env.LANGFUSE_DEFAULT_ORG_ID ?? [];
const defaultOrgs =
defaultOrgIds.length > 0
? await prisma.organization.findMany({
where: {
id: { in: defaultOrgIds },
},
})
: [];
// Create org memberships for all default orgs, store mapping of orgId -> membership
const orgMembershipMap = new Map<
string,
{ id: string; orgId: string; userId: string }
>();
for (const org of defaultOrgs) {
const membership = await prisma.organizationMembership.upsert({
where: {
orgId_userId: { orgId: org.id, userId: user.id },
},
update: {}, // No-op: preserve existing role
create: {
orgId: org.id,
userId: user.id,
role: env.LANGFUSE_DEFAULT_ORG_ROLE ?? "VIEWER",
},
});
orgMembershipMap.set(org.id, membership);
}
// self-hosted: LANGFUSE_DEFAULT_PROJECT_ID (supports comma-separated list of project IDs)
const defaultProjectIds = env.LANGFUSE_DEFAULT_PROJECT_ID ?? [];
const defaultProjects =
defaultProjectIds.length > 0
? await prisma.project.findMany({
where: {
id: { in: defaultProjectIds },
},
})
: [];
// Project-level role assignments require the rbac-project-roles entitlement.
// Without it, users inherit their org role for all projects, so we only need
// to ensure org membership exists (handled above and in path 2 below).
const hasProjectRolesEntitlement = hasEntitlementBasedOnPlan({
plan: getOrganizationPlanServerSide(),
entitlement: "rbac-project-roles",
});
for (const project of defaultProjects) {
const existingOrgMembership = orgMembershipMap.get(project.orgId);
if (existingOrgMembership) {
// (1) project's org is in the default org list -> create project membership if entitled
if (hasProjectRolesEntitlement) {
await prisma.projectMembership.upsert({
where: {
projectId_userId: {
projectId: project.id,
userId: user.id,
},
},
update: {}, // No-op: preserve existing role
create: {
userId: user.id,
orgMembershipId: existingOrgMembership.id,
projectId: project.id,
role: env.LANGFUSE_DEFAULT_PROJECT_ROLE ?? "VIEWER",
},
});
}
} else {
// (2) project's org is NOT in the default org list (legacy behavior) -> create org membership for the project's org first
const orgMembership = await prisma.organizationMembership.upsert({
where: {
orgId_userId: { orgId: project.orgId, userId: user.id },
},
update: {}, // No-op: preserve existing role
create: {
orgId: project.orgId,
userId: user.id,
role: env.LANGFUSE_DEFAULT_PROJECT_ROLE ?? "VIEWER",
},
});
// Add to map in case multiple projects belong to the same org
orgMembershipMap.set(project.orgId, orgMembership);
if (hasProjectRolesEntitlement) {
await prisma.projectMembership.upsert({
where: {
projectId_userId: {
projectId: project.id,
userId: user.id,
},
},
update: {}, // No-op: preserve existing role
create: {
userId: user.id,
orgMembershipId: orgMembership.id,
projectId: project.id,
role: env.LANGFUSE_DEFAULT_PROJECT_ROLE ?? "VIEWER",
},
});
}
}
}
// SFDC lead upsert (never throws; no-op when SfdcService is not
// configured).
// Must run BEFORE processMembershipInvitations below so the lead exists
// when setUserRole events fire for accepted invitations — which is also
// why the invitation lookup for the lead source runs here, while the
// invitations still exist.
if (options?.userWasJustCreated || isNewUser) {
const sfdcService = getSfdcService();
if (sfdcService) {
const dbUser = await prisma.user.findUnique({
where: { id: user.id },
select: { createdAt: true },
});
const hasPendingInvitation = user.email
? (await prisma.membershipInvitation.findFirst({
where: { email: user.email.toLowerCase() },
select: { id: true },
})) !== null
: false;
await sfdcService.upsertUser({
userId: user.id,
email: user.email,
name: user.name,
createdAt: dbUser?.createdAt ?? new Date(),
leadSource: hasPendingInvitation
? "Langfuse Cloud Invite"
: "Langfuse Cloud Signup",
});
}
}
// Invites do not work for users without emails (some future SSO users)
const joinedRealOrganizationViaInvitation = user.email
? await processMembershipInvitations(user.email, user.id)
: false;
if (
isCloudDeployment &&
!joinedRealOrganizationViaInvitation &&
canCreateOrganizations(user.email) &&
(options?.userWasJustCreated || isNewUser)
) {
const starterOrg = await provisionStarterOrganizationForNewUser({
prisma,
userId: user.id,
userName: user.name,
});
if (starterOrg) {
await getSfdcService()?.upsertOrg({
orgId: starterOrg.organization.id,
orgName: starterOrg.organization.name,
createdAt: starterOrg.organization.createdAt,
plan: "Hobby",
});
await getSfdcService()?.setUserRole({
orgId: starterOrg.organization.id,
userId: user.id,
email: user.email,
role: "OWNER",
});
}
}
if (isCloudDeployment && (options?.userWasJustCreated || isNewUser)) {
const userRolloutState = await prisma.user.findUnique({
where: { id: user.id },
select: {
createdAt: true,
v4BetaEnabled: true,
organizationMemberships: {
select: {
organization: {
select: {
id: true,
createdAt: true,
},
},
},
},
},
});
if (userRolloutState) {
const shouldAutoEnableV4ForUser = shouldAutoEnableV4({
userCreatedAt: userRolloutState.createdAt,
organizations: userRolloutState.organizationMemberships.map(
(membership) => ({
id: membership.organization.id,
createdAt: membership.organization.createdAt,
}),
),
excludedOrganizationIds: env.NEXT_PUBLIC_DEMO_ORG_ID
? [env.NEXT_PUBLIC_DEMO_ORG_ID]
: [],
});
const shouldInitializeForNewUser =
options?.userWasJustCreated &&
!userRolloutState.v4BetaEnabled &&
shouldAutoEnableV4ForUser;
const shouldInitializeForFirstOrganization =
!options?.userWasJustCreated &&
isNewUser &&
!userRolloutState.v4BetaEnabled &&
shouldAutoEnableV4ForUser;
if (
shouldInitializeForNewUser ||
shouldInitializeForFirstOrganization
) {
await prisma.user.update({
where: { id: user.id },
data: { v4BetaEnabled: true },
});
}
}
}
// for conversion metric tracking in posthog: did a new user sign up?
// Fires on all production cloud regions, including ones added in the
// future. STAGING/DEV are excluded to keep test signups out of
// conversion metrics, and self-hosted deployments never emit this
// event as the region env is unset. HIPAA still constructs ServerPosthog
// here; the client is opted out via disable() so the capture is a no-op.
if (
isNewUser &&
env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION &&
!["STAGING", "DEV"].includes(env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION)
) {
try {
const posthog = new ServerPosthog();
posthog.capture({
distinctId: user.id,
event: "cloud_signup_complete",
properties: {
cloudRegion: env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION,
hasDemoAccess: demoProject !== undefined,
hasDefaultOrg: defaultOrgs.length > 0,
hasDefaultProject: defaultProjects.length > 0,
// Google Ads click id for ad conversion attribution
// ad-platform click ids (gclid, li_fat_id, rdt_cid, twclid)
// for ad conversion attribution; only resolved ids are present
...(options?.adClickIds ?? {}),
},
});
await posthog.shutdown();
} catch {
// analytics tracking failure is not critical, just fail
}
}
} catch (e) {
logger.error("Error assigning project access to new user", e);
}
}
async function processMembershipInvitations(email: string, userId: string) {
const invitationsForUser = await prisma.membershipInvitation.findMany({
where: {
email: email.toLowerCase(),
},
});
if (invitationsForUser.length === 0) return false;
const joinedRealOrganizationViaInvitation = invitationsForUser.some(
(invitation) => {
if (invitation.orgId === env.NEXT_PUBLIC_DEMO_ORG_ID) return false;
// Gateway-only members see no projects but belong in the inviting org,
// where they create their AI Gateway keys, as long as it still has the
// gateway enabled.
if (
invitation.orgRole === Role.AI_GATEWAY &&
isGatewayEnabledForOrganization(invitation.orgId)
) {
return true;
}
if (!invitation.projectId) return false;
const projectRole = invitation.projectRole ?? invitation.orgRole;
return projectRoleAccessRights[projectRole].includes("project:read");
},
);
// Map to individual payloads instead of using createMany as we can thereby use nested writes for ProjectMemberships
const createOrgMembershipData = invitationsForUser.map((invitation) => ({
userId: userId,
orgId: invitation.orgId,
role: invitation.orgRole,
...(invitation.projectId && invitation.projectRole
? {
ProjectMemberships: {
create: {
userId: userId,
projectId: invitation.projectId,
role: invitation.projectRole,
},
},
}
: {}),
}));
const createOrgMembershipsPromises = createOrgMembershipData.map(
(inviteData) => prisma.organizationMembership.create({ data: inviteData }),
);
await prisma.$transaction([
...createOrgMembershipsPromises,
prisma.membershipInvitation.deleteMany({
where: {
id: {
in: invitationsForUser.map((invitation) => invitation.id),
},
email: email.toLowerCase(),
},
}),
]);
// SFDC: link the freshly-created lead to each org as an org-member.
await Promise.all(
invitationsForUser.map((invitation) =>
getSfdcService()?.setUserRole({
orgId: invitation.orgId,
userId,
email,
role: invitation.orgRole,
}),
),
);
return joinedRealOrganizationViaInvitation;
}