Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

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.ts
index 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.ts
index 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 that
diff --git a/web/src/ee/features/sfdc-sync/server/index.ts b/web/src/ee/features/sfdc-sync/server/index.ts
index 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.ts
new file mode 100644
index 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.ts
index 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,
+ });
}