🪢 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
fix(sfdc): link existing members when a pre-sync org upgrades from Hobby (#18515)
Steffen Reuthera86bbfd1e54f
diff --git a/web/src/__tests__/server/unit/sfdc-sync.servertest.ts b/web/src/__tests__/server/unit/sfdc-sync.servertest.tsindex ab78cbd87b..393ae5c740 100644--- a/web/src/__tests__/server/unit/sfdc-sync.servertest.ts+++ b/web/src/__tests__/server/unit/sfdc-sync.servertest.ts@@ -657,6 +657,158 @@ describe("syncOrgPlanChangeToSfdc — plan-change gate for billing updates", ()expect(fetchMock).not.toHaveBeenCalled();expect(loggerMock.error).toHaveBeenCalled();});++ describe("member re-link for orgs that predate the live sync", () => {+ const PRE_SYNC_SIGNUP_AT = new Date("2026-05-02T10:00:00.000Z");+ const sentBodies = () =>+ fetchMock.mock.calls.map(+ ([, init]) =>+ JSON.parse(init.body as string) as Record<string, unknown>,+ );++ beforeEach(() => {+ fetchMock.mockImplementation(async () => emptyOkResponse());+ });+ afterEach(() => {+ fetchMock.mockReset();+ });++ // The re-link runs in the background; its summary line marks the end.+ const relinkFinished = (summary: Record<string, unknown>) =>+ vi.waitFor(() =>+ expect(loggerMock.info).toHaveBeenCalledWith(+ "[SFDC] linked existing members after plan change",+ expect.objectContaining(summary),+ ),+ );+ const preSyncOwner = {+ userId: "owner-old",+ role: "OWNER",+ user: {+ email: "[email protected]",+ name: "Old Owner",+ createdAt: PRE_SYNC_SIGNUP_AT,+ },+ };++ it("links every member on the Hobby→paid upgrade, upserting Leads only for pre-sync signups", async () => {+ prismaMock.organizationMembership.findMany.mockResolvedValueOnce([+ preSyncOwner,+ {+ userId: "member-new",+ role: "MEMBER",+ user: {+ email: "[email protected]",+ name: "New Member",+ createdAt: SIGNUP_AT,+ },+ },+ ]);+ // Lead-source heuristic: the owner's earliest membership was as OWNER.+ prismaMock.organizationMembership.findFirst.mockResolvedValueOnce({+ role: "OWNER",+ });++ await syncOrgPlanChangeToSfdc({+ orgBeforeUpdate: orgBefore(null),+ updatedCloudConfig: stripeConfig(PRO_PRODUCT),+ billingCycleAnchor: CONVERTED_AT,+ });++ await relinkFinished({ orgId: "org-1", members: 2, linked: 2 });++ // Account first, then each member's Lead before its bridge. The+ // post-sync member got its Lead at signup — only the bridge is sent.+ expect(sentBodies()).toEqual([+ expect.objectContaining({ type: "updateOrg", plan: "Pro" }),+ expect.objectContaining({+ userId: "owner-old",+ email: "[email protected]",+ leadSource: "Langfuse Cloud Signup",+ }),+ expect.objectContaining({+ type: "setUserRole",+ orgId: "org-1",+ userId: "owner-old",+ role: "ADMIN",+ }),+ expect.objectContaining({+ type: "setUserRole",+ orgId: "org-1",+ userId: "member-new",+ role: "DEVELOPER",+ }),+ ]);+ });++ it("sends no bridge for a member whose Lead was not delivered", async () => {+ fetchMock.mockImplementation(async (url: string) =>+ url === "https://mulesoft.test/manage-user"+ ? nonOkResponse(500)+ : emptyOkResponse(),+ );+ prismaMock.organizationMembership.findMany.mockResolvedValueOnce([+ preSyncOwner,+ ]);++ await syncOrgPlanChangeToSfdc({+ orgBeforeUpdate: orgBefore(null),+ updatedCloudConfig: stripeConfig(PRO_PRODUCT),+ billingCycleAnchor: CONVERTED_AT,+ });+ await relinkFinished({ members: 1, linked: 0 });++ expect(sentBodies().map((body) => body.type ?? "upsertUser")).toEqual([+ "updateOrg",+ "upsertUser",+ ]);+ });++ it("keeps a member query failure inside the re-link", async () => {+ prismaMock.organizationMembership.findMany.mockRejectedValueOnce(+ new Error("db down"),+ );++ await expect(+ syncOrgPlanChangeToSfdc({+ orgBeforeUpdate: orgBefore(null),+ updatedCloudConfig: stripeConfig(PRO_PRODUCT),+ billingCycleAnchor: CONVERTED_AT,+ }),+ ).resolves.toBeUndefined();+ await vi.waitFor(() =>+ expect(loggerMock.error).toHaveBeenCalledWith(+ "[SFDC] failed to link existing members after plan change",+ { orgId: "org-1", error: "db down" },+ ),+ );+ expect(fetchMock).toHaveBeenCalledOnce();+ });++ it("does not re-link members of orgs created after the live sync started", async () => {+ await syncOrgPlanChangeToSfdc({+ orgBeforeUpdate: {+ ...orgBefore(null),+ createdAt: new Date("2026-08-01T00:00:00.000Z"),+ },+ updatedCloudConfig: stripeConfig(PRO_PRODUCT),+ billingCycleAnchor: CONVERTED_AT,+ });+ expect(fetchMock).toHaveBeenCalledOnce();+ expect(prismaMock.organizationMembership.findMany).not.toHaveBeenCalled();+ });++ it("does not link members when the account push fails", async () => {+ fetchMock.mockImplementation(async () => nonOkResponse(500));+ await syncOrgPlanChangeToSfdc({+ orgBeforeUpdate: orgBefore(null),+ updatedCloudConfig: stripeConfig(PRO_PRODUCT),+ billingCycleAnchor: CONVERTED_AT,+ });+ expect(fetchMock).toHaveBeenCalledOnce();+ expect(prismaMock.organizationMembership.findMany).not.toHaveBeenCalled();+ });+ });});// ---- Call sites ----diff --git a/web/src/ee/features/sfdc-sync/scripts/backfillSfdcLeads.ts b/web/src/ee/features/sfdc-sync/scripts/backfillSfdcLeads.tsindex 1cf9c840e3..5bdf659558 100644--- a/web/src/ee/features/sfdc-sync/scripts/backfillSfdcLeads.ts+++ b/web/src/ee/features/sfdc-sync/scripts/backfillSfdcLeads.ts@@ -126,9 +126,9 @@ import { parseArgs } from "node:util";import { env } from "@/src/env.mjs";import {+ deriveLeadSourceFromMemberships,getSfdcService,toSfdcPlan,- type SfdcLeadSource,} from "@/src/ee/features/sfdc-sync/server";import { getOrganizationPlanServerSide } from "@/src/features/entitlements/server";import { parseDbOrg } from "@langfuse/shared";@@ -330,22 +330,8 @@ async function main() {// Lead source from the user's global membership history — must not depend// on which org unit triggers the send, or multi-org users would get// order-dependent values.- const resolveLeadSource = async (userId: string): Promise<SfdcLeadSource> => {- const firstMembership = await prisma.organizationMembership.findFirst({- where: {- userId,- role: { not: Role.NONE },- ...nonExcludedOrgFilter,- },- orderBy: { createdAt: "asc" },- select: { role: true },- });- if (firstMembership)- return firstMembership.role === Role.OWNER- ? "Langfuse Cloud Signup"- : "Langfuse Cloud Invite";- return "Langfuse Cloud Signup";- };+ const resolveLeadSource = (userId: string) =>+ deriveLeadSourceFromMemberships(userId, [...cli.excludeOrgIds]);// One Lead send per user per run; multi-org users keep their first outcome// (identical payload either way, and a failed lead marks every org thatdiff --git a/web/src/ee/features/sfdc-sync/server/index.ts b/web/src/ee/features/sfdc-sync/server/index.tsindex f8ba03c1f3..3a18098e05 100644--- a/web/src/ee/features/sfdc-sync/server/index.ts+++ b/web/src/ee/features/sfdc-sync/server/index.ts@@ -5,4 +5,5 @@ export {toSfdcPlan,} from "./sfdcService";export { syncOrgPlanChangeToSfdc } from "./planChangeSync";+export { deriveLeadSourceFromMemberships } from "./leadSource";export type { SfdcLeadSource } from "./sfdcService";diff --git a/web/src/ee/features/sfdc-sync/server/leadSource.ts b/web/src/ee/features/sfdc-sync/server/leadSource.tsnew file mode 100644index 0000000000..c8d74e4179--- /dev/null+++ b/web/src/ee/features/sfdc-sync/server/leadSource.ts@@ -0,0 +1,36 @@+import { prisma, Role } from "@langfuse/shared/src/db";++import { type SfdcLeadSource } from "./sfdcService";++/**+ * Lead source for a user whose Lead is sent after the fact (backfill, member+ * re-link) rather than at signup. Derived from the user's GLOBAL membership+ * history so every caller sends the same value regardless of which org+ * triggered the send: earliest non-NONE membership created with role OWNER →+ * "Langfuse Cloud Signup", any other role → "Langfuse Cloud Invite"; no such+ * membership → Signup. Accepted invitations are deleted on accept, so this+ * is a heuristic, not a record.+ *+ * `excludeOrgIds` must contain the demo org: every Cloud signup holds a+ * VIEWER membership there, which would otherwise flip every organic signup+ * to "Invite".+ */+export async function deriveLeadSourceFromMemberships(+ userId: string,+ excludeOrgIds: string[],+): Promise<SfdcLeadSource> {+ const firstMembership = await prisma.organizationMembership.findFirst({+ where: {+ userId,+ role: { not: Role.NONE },+ ...(excludeOrgIds.length > 0 ? { orgId: { notIn: excludeOrgIds } } : {}),+ },+ orderBy: { createdAt: "asc" },+ select: { role: true },+ });+ if (firstMembership)+ return firstMembership.role === Role.OWNER+ ? "Langfuse Cloud Signup"+ : "Langfuse Cloud Invite";+ return "Langfuse Cloud Signup";+}diff --git a/web/src/ee/features/sfdc-sync/server/planChangeSync.ts b/web/src/ee/features/sfdc-sync/server/planChangeSync.tsindex 7e14ed4c5d..99d105b6ec 100644--- a/web/src/ee/features/sfdc-sync/server/planChangeSync.ts+++ b/web/src/ee/features/sfdc-sync/server/planChangeSync.ts@@ -1,15 +1,28 @@import { CloudConfigSchema, type ParsedOrganization } from "@langfuse/shared";-import { logger } from "@langfuse/shared/src/server";+import { prisma, Role } from "@langfuse/shared/src/db";+import { logger, traceException } from "@langfuse/shared/src/server";+import { env } from "@/src/env.mjs";import { getOrganizationPlanServerSide } from "@/src/features/entitlements/server";-import { getSfdcService, toSfdcPlan } from "./sfdcService";+import { deriveLeadSourceFromMemberships } from "./leadSource";+import { getSfdcService, toSfdcPlan, type SfdcService } from "./sfdcService";++/**+ * Since the live sync went live on Cloud (late June 2026), every org has had+ * its members linked in SFDC as the memberships were created. Older orgs were+ * linked only by the historical backfill, which skipped orgs that were on+ * Hobby at the time. Set a few days after go-live: a later cutoff only+ * re-sends idempotent events, an earlier one would miss orgs.+ */+const SFDC_LIVE_SYNC_STARTED_AT = new Date("2026-07-01T00:00:00Z");/*** Push a plan change to SFDC (fire-and-forget, never throws — the underlying- * SfdcService swallows all errors). Compares the entitlement plan resolved- * from the org's cloudConfig before vs. after a billing update and only syncs- * when it actually changed — Stripe subscription events also fire for monthly- * invoice cycling and payment-status flaps, which must not spam Mulesoft.+ * SfdcService swallows all errors, and the member re-link catches its own).+ * Compares the entitlement plan resolved from the org's cloudConfig before+ * vs. after a billing update and only syncs when it actually changed — Stripe+ * subscription events also fire for monthly invoice cycling and+ * payment-status flaps, which must not spam Mulesoft.** `billingCycleAnchor` doubles as the Hobby→paid conversion date: it is set* from the org's paid subscription and stable across plan switches, but NOT@@ -20,6 +33,11 @@ import { getSfdcService, toSfdcPlan } from "./sfdcService";* written value). Orgs on a manual cloudConfig.plan override never reach the* push: the override wins plan resolution on both sides of the comparison,* so their resolved plan cannot change here — sales owns those SFDC records.+ *+ * When an org created before the live sync leaves Hobby, its current members+ * are linked as well, since neither the live sync nor the backfill may ever+ * have linked them. That re-link runs in the background once the account+ * push is acked, so the returned promise does not wait for it.*/export async function syncOrgPlanChangeToSfdc(args: {orgBeforeUpdate: Pick<@@ -52,7 +70,10 @@ export async function syncOrgPlanChangeToSfdc(args: {const sfdcPlan = toSfdcPlan(planAfter);if (!sfdcPlan) return; // non-cloud plan — cannot happen on Cloud- await getSfdcService()?.upsertOrg({+ const sfdc = getSfdcService();+ if (!sfdc) return;++ const accountOk = await sfdc.upsertOrg({orgId: orgBeforeUpdate.id,orgName: orgBeforeUpdate.name,createdAt: orgBeforeUpdate.createdAt,@@ -60,4 +81,74 @@ export async function syncOrgPlanChangeToSfdc(args: {convertedToPaidAt:planAfter !== "cloud:hobby" ? billingCycleAnchor : undefined,});++ // Member bridges need the Account, so they wait for its 2xx. Not awaited:+ // the Stripe webhook must not wait on per-member Mulesoft calls.+ if (+ accountOk &&+ planBefore === "cloud:hobby" &&+ orgBeforeUpdate.createdAt < SFDC_LIVE_SYNC_STARTED_AT+ ) {+ const orgId = orgBeforeUpdate.id;+ linkExistingMembersToSfdc(sfdc, orgId).catch((err) => {+ // SfdcService never rejects, so this is a membership read failing.+ traceException(err);+ logger.error("[SFDC] failed to link existing members after plan change", {+ orgId,+ error: err instanceof Error ? err.message : String(err),+ });+ });+ }+}++/**+ * Replays the backfill's member steps for one org: a Lead for every member+ * who signed up before the live sync (later signups got theirs at signup),+ * then the org-member bridge for every member. A member whose Lead was not+ * delivered gets no bridge, since SFDC needs the Lead first. Members are+ * processed one at a time so an upgrade never bursts Mulesoft.+ */+async function linkExistingMembersToSfdc(+ sfdc: SfdcService,+ orgId: string,+): Promise<void> {+ const members = await prisma.organizationMembership.findMany({+ where: {+ orgId,+ role: { not: Role.NONE },+ user: { email: { not: null } },+ },+ select: {+ userId: true,+ role: true,+ user: { select: { email: true, name: true, createdAt: true } },+ },+ });+ const excludeOrgIds = env.NEXT_PUBLIC_DEMO_ORG_ID+ ? [env.NEXT_PUBLIC_DEMO_ORG_ID]+ : [];++ let linked = 0;+ for (const { userId, role, user } of members) {+ if (user.createdAt < SFDC_LIVE_SYNC_STARTED_AT) {+ const leadOk = await sfdc.upsertUser({+ userId,+ email: user.email,+ name: user.name,+ createdAt: user.createdAt,+ leadSource: await deriveLeadSourceFromMemberships(+ userId,+ excludeOrgIds,+ ),+ });+ if (!leadOk) continue;+ }+ if (await sfdc.setUserRole({ orgId, userId, email: user.email, role }))+ linked++;+ }+ logger.info("[SFDC] linked existing members after plan change", {+ orgId,+ members: members.length,+ linked,+ });}