🪢 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
feat(feature-preview): enable org level setting of feature flag defaults (#16426)
Nimarc4afb10866d7
diff --git a/packages/shared/prisma/migrations/20260825120000_add_organization_feature_flag_defaults/migration.sql b/packages/shared/prisma/migrations/20260825120000_add_organization_feature_flag_defaults/migration.sqlnew file mode 100644index 0000000000..1c6a2125e0--- /dev/null+++ b/packages/shared/prisma/migrations/20260825120000_add_organization_feature_flag_defaults/migration.sql@@ -0,0 +1,2 @@+ALTER TABLE "organizations"+ADD COLUMN "feature_flag_org_defaults" TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[];diff --git a/packages/shared/prisma/schema.prisma b/packages/shared/prisma/schema.prismaindex 38002b8eea..af4a84178d 100644--- a/packages/shared/prisma/schema.prisma+++ b/packages/shared/prisma/schema.prisma@@ -109,6 +109,7 @@ model Organization {cloudFreeTierUsageThresholdState String? @map("cloud_free_tier_usage_threshold_state")aiFeaturesEnabled Boolean @default(false) @map("ai_features_enabled")aiTelemetryEnabled Boolean @default(true) @map("ai_telemetry_enabled")+ featureFlagOrgDefaults String[] @default([]) @map("feature_flag_org_defaults")// SFDC Account / Organization ID returned by the Mulesoft org endpoint on// Langfuse Cloud. NULL for self-hosted or pre-integration orgs. A mismatch// between the stored value and a subsequently returned ID indicates an SFDCdiff --git a/web/src/__tests__/server/organization-feature-flags.servertest.ts b/web/src/__tests__/server/organization-feature-flags.servertest.tsnew file mode 100644index 0000000000..06af6722f2--- /dev/null+++ b/web/src/__tests__/server/organization-feature-flags.servertest.ts@@ -0,0 +1,557 @@+import type { Session } from "next-auth";+import { randomUUID } from "node:crypto";++import { Role, type Plan } from "@langfuse/shared";+import { prisma } from "@langfuse/shared/src/db";+import { env } from "@/src/env.mjs";+import { getFeaturePreviewOptOutFlag } from "@/src/features/feature-flags/utils";+import { appRouter } from "@/src/server/api/root";+import { createInnerTRPCContext } from "@/src/server/api/trpc";++describe("organization feature preview defaults", () => {+ it("enables a default without mutating current members", async () => {+ const { actor, caller, org } = await prepare();+ await prisma.user.update({+ where: { id: actor.id },+ data: { featureFlags: ["modernSession"] },+ });+ const member = await createUser();+ await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: member.id, role: Role.MEMBER },+ });++ await caller.organizations.setFeatureFlagOrgDefault({+ orgId: org.id,+ flag: "modernSession",+ enabled: true,+ });++ const [updatedOrg, updatedActor, updatedMember] = await Promise.all([+ prisma.organization.findUniqueOrThrow({+ where: { id: org.id },+ select: { featureFlagOrgDefaults: true },+ }),+ prisma.user.findUniqueOrThrow({+ where: { id: actor.id },+ select: { featureFlags: true },+ }),+ prisma.user.findUniqueOrThrow({+ where: { id: member.id },+ select: { featureFlags: true },+ }),+ ]);++ expect(updatedOrg.featureFlagOrgDefaults).toEqual(["modernSession"]);+ expect(updatedActor.featureFlags).toEqual(["modernSession"]);+ expect(updatedMember.featureFlags).toEqual([]);+ const auditEntry = await prisma.auditLog.findFirstOrThrow({+ where: {+ orgId: org.id,+ resourceType: "organization",+ resourceId: org.id,+ action: "updateFeatureFlagDefault",+ },+ orderBy: { createdAt: "desc" },+ });+ expect(JSON.parse(auditEntry.before!)).toEqual({+ featureFlagOrgDefaults: [],+ });+ expect(JSON.parse(auditEntry.after!)).toEqual({+ featureFlagOrgDefaults: ["modernSession"],+ });+ });++ it("allows tested administrators and rejects ordinary organization members", async () => {+ const admin = await prepare("cloud:core", Role.ADMIN);+ await prisma.user.update({+ where: { id: admin.actor.id },+ data: { featureFlags: ["compactTimeline"] },+ });+ await expect(+ admin.caller.organizations.setFeatureFlagOrgDefault({+ orgId: admin.org.id,+ flag: "compactTimeline",+ enabled: true,+ }),+ ).resolves.toMatchObject({ enabled: true });++ const member = await prepare("cloud:core", Role.MEMBER);+ await expect(+ member.caller.organizations.setFeatureFlagOrgDefault({+ orgId: member.org.id,+ flag: "compactTimeline",+ enabled: true,+ }),+ ).rejects.toMatchObject({ code: "FORBIDDEN" });+ await expect(+ member.caller.organizations.getFeatureFlagOrgDefaults({+ orgId: member.org.id,+ }),+ ).rejects.toMatchObject({ code: "FORBIDDEN" });+ const members = await member.caller.members.allFromOrg({+ orgId: member.org.id,+ page: 0,+ limit: 10,+ });+ expect(members.memberships[0]?.featurePreviews).toBeNull();+ expect(members.memberships[0]?.featurePreviewManagement).toBeNull();+ });++ it("rejects enabling a default until the administrator has the preview enabled personally", async () => {+ const { caller, org } = await prepare();++ await expect(+ caller.organizations.setFeatureFlagOrgDefault({+ orgId: org.id,+ flag: "compactTimeline",+ enabled: true,+ }),+ ).rejects.toMatchObject({ code: "PRECONDITION_FAILED" });+ });++ it("rejects internal flags at the input boundary", async () => {+ const { caller, org } = await prepare();++ await expect(+ caller.organizations.setFeatureFlagOrgDefault({+ orgId: org.id,+ flag: "templateFlag" as never,+ enabled: true,+ }),+ ).rejects.toMatchObject({ code: "BAD_REQUEST" });+ });++ it("is idempotent and preserves unknown organization defaults", async () => {+ const { actor, caller, org } = await prepare();+ await Promise.all([+ prisma.user.update({+ where: { id: actor.id },+ data: { featureFlags: ["modernSession"] },+ }),+ prisma.organization.update({+ where: { id: org.id },+ data: { featureFlagOrgDefaults: ["futurePreview"] },+ }),+ ]);++ for (const enabled of [true, true]) {+ await caller.organizations.setFeatureFlagOrgDefault({+ orgId: org.id,+ flag: "modernSession",+ enabled,+ });+ }+ await expect(+ prisma.organization.findUniqueOrThrow({+ where: { id: org.id },+ select: { featureFlagOrgDefaults: true },+ }),+ ).resolves.toEqual({+ featureFlagOrgDefaults: ["futurePreview", "modernSession"],+ });++ for (const enabled of [false, false]) {+ await caller.organizations.setFeatureFlagOrgDefault({+ orgId: org.id,+ flag: "modernSession",+ enabled,+ });+ }+ await expect(+ prisma.organization.findUniqueOrThrow({+ where: { id: org.id },+ select: { featureFlagOrgDefaults: true },+ }),+ ).resolves.toEqual({+ featureFlagOrgDefaults: ["futurePreview"],+ });+ });++ it("applies defaults to a new member context without copying them to the user", async () => {+ const { caller, org } = await prepare();+ await prisma.organization.update({+ where: { id: org.id },+ data: { featureFlagOrgDefaults: ["modernSession", "compactTimeline"] },+ });+ const member = await createUser({+ featureFlags: [+ "templateFlag",+ getFeaturePreviewOptOutFlag("modernSession"),+ ],+ });++ await caller.members.create({+ orgId: org.id,+ email: member.email!,+ orgRole: Role.MEMBER,+ });++ const [updated, members] = await Promise.all([+ prisma.user.findUniqueOrThrow({+ where: { id: member.id },+ select: { featureFlags: true },+ }),+ caller.members.allFromOrg({ orgId: org.id, page: 0, limit: 10 }),+ ]);+ expect(updated.featureFlags).toEqual([+ "templateFlag",+ getFeaturePreviewOptOutFlag("modernSession"),+ ]);+ expect(+ members.memberships.find((membership) => membership.userId === member.id)+ ?.featurePreviews,+ ).toEqual({+ modernSession: false,+ compactTimeline: true,+ });+ });++ it("rejects default changes for the demo organization", async () => {+ const originalDemoOrgId = env.NEXT_PUBLIC_DEMO_ORG_ID;+ const { caller, org } = await prepare();+ (env as { NEXT_PUBLIC_DEMO_ORG_ID?: string }).NEXT_PUBLIC_DEMO_ORG_ID =+ org.id;++ try {+ await expect(+ caller.organizations.setFeatureFlagOrgDefault({+ orgId: org.id,+ flag: "modernSession",+ enabled: true,+ }),+ ).rejects.toMatchObject({ code: "FORBIDDEN" });+ const members = await caller.members.allFromOrg({+ orgId: org.id,+ page: 0,+ limit: 10,+ });+ expect(members.memberships[0]?.featurePreviews).toBeNull();+ expect(members.memberships[0]?.featurePreviewManagement).toBeNull();+ } finally {+ (env as { NEXT_PUBLIC_DEMO_ORG_ID?: string }).NEXT_PUBLIC_DEMO_ORG_ID =+ originalDemoOrgId;+ }+ });+});++describe("organization member feature preview overrides", () => {+ it("persists an administrator's disable as a global user opt-out", async () => {+ const { caller, org } = await prepare();+ const target = await createUser({ featureFlags: ["compactTimeline"] });+ await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },+ });++ await caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "compactTimeline",+ enabled: false,+ });++ await expect(+ prisma.user.findUniqueOrThrow({+ where: { id: target.id },+ select: { featureFlags: true },+ }),+ ).resolves.toEqual({+ featureFlags: [getFeaturePreviewOptOutFlag("compactTimeline")],+ });+ });++ it("audits disabling an inherited organization default as a global override", async () => {+ const { caller, org } = await prepare();+ await prisma.organization.update({+ where: { id: org.id },+ data: { featureFlagOrgDefaults: ["compactTimeline"] },+ });+ const target = await createUser();+ const membership = await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },+ });++ await caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "compactTimeline",+ enabled: false,+ });++ const auditEntry = await prisma.auditLog.findFirstOrThrow({+ where: {+ orgId: org.id,+ resourceType: "orgMembership",+ resourceId: membership.id,+ action: "updateUserFeatureFlag",+ },+ orderBy: { createdAt: "desc" },+ });+ expect(JSON.parse(auditEntry.before!)).toEqual({+ flag: "compactTimeline",+ override: "inherit",+ scope: "global",+ });+ expect(JSON.parse(auditEntry.after!)).toEqual({+ flag: "compactTimeline",+ override: "disabled",+ scope: "global",+ });+ });++ it("allows a platform administrator across organizations and writes a minimal audit entry", async () => {+ const { caller, org } = await prepare("cloud:core", Role.OWNER, true);+ const target = await createUser();+ const currentMembership = await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },+ });+ const otherOrg = await createOrganization();+ await prisma.organizationMembership.create({+ data: { orgId: otherOrg.id, userId: target.id, role: Role.VIEWER },+ });++ await caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "compactTimeline",+ enabled: true,+ });++ const auditEntry = await prisma.auditLog.findFirstOrThrow({+ where: {+ orgId: org.id,+ resourceType: "orgMembership",+ resourceId: currentMembership.id,+ action: "updateUserFeatureFlag",+ },+ orderBy: { createdAt: "desc" },+ });+ expect(JSON.parse(auditEntry.before!)).toEqual({+ flag: "compactTimeline",+ override: "inherit",+ scope: "global",+ });+ expect(JSON.parse(auditEntry.after!)).toEqual({+ flag: "compactTimeline",+ override: "enabled",+ scope: "global",+ });+ });++ it("denies a targeted change unless the actor administers every real target organization", async () => {+ const { actor, caller, org } = await prepare();+ const target = await createUser();+ await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },+ });+ const otherOrg = await createOrganization();+ await prisma.organizationMembership.create({+ data: { orgId: otherOrg.id, userId: target.id, role: Role.VIEWER },+ });++ const members = await caller.members.allFromOrg({+ orgId: org.id,+ page: 0,+ limit: 10,+ });+ const targetRow = members.memberships.find(+ (membership) => membership.userId === target.id,+ );+ expect(targetRow?.featurePreviewManagement).toEqual({ allowed: false });++ await expect(+ caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "modernSession",+ enabled: true,+ }),+ ).rejects.toMatchObject({ code: "FORBIDDEN" });++ await prisma.organizationMembership.create({+ data: { orgId: otherOrg.id, userId: actor.id, role: Role.ADMIN },+ });+ await expect(+ caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "modernSession",+ enabled: true,+ }),+ ).resolves.toMatchObject({+ userId: target.id,+ flag: "modernSession",+ enabled: true,+ });+ });++ it("ignores demo membership in the all-organizations check", async () => {+ const originalDemoOrgId = env.NEXT_PUBLIC_DEMO_ORG_ID;+ const { caller, org } = await prepare();+ const target = await createUser();+ await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },+ });+ const demoOrg = await createOrganization();+ await prisma.organizationMembership.create({+ data: { orgId: demoOrg.id, userId: target.id, role: Role.VIEWER },+ });+ (env as { NEXT_PUBLIC_DEMO_ORG_ID?: string }).NEXT_PUBLIC_DEMO_ORG_ID =+ demoOrg.id;++ try {+ await expect(+ caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "compactTimeline",+ enabled: true,+ }),+ ).resolves.toMatchObject({ enabled: true });+ } finally {+ (env as { NEXT_PUBLIC_DEMO_ORG_ID?: string }).NEXT_PUBLIC_DEMO_ORG_ID =+ originalDemoOrgId;+ }+ });++ it("does not expose raw or foreign-organization feature flag data", async () => {+ const { caller, org } = await prepare();+ const target = await createUser({+ featureFlags: ["templateFlag", "compactTimeline"],+ });+ await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },+ });++ const result = await caller.members.allFromOrg({+ orgId: org.id,+ page: 0,+ limit: 10,+ });+ const row = result.memberships.find(+ (membership) => membership.userId === target.id,+ );++ expect(row?.featurePreviews).toEqual({+ modernSession: false,+ compactTimeline: true,+ });+ expect(row?.user).not.toHaveProperty("featureFlags");+ expect(row).not.toHaveProperty("organizationIds");+ });++ it("rejects a target that is not a member of the input organization", async () => {+ const { caller, org } = await prepare();+ const target = await createUser();++ await expect(+ caller.members.setUserFeaturePreviewEnabled({+ orgId: org.id,+ userId: target.id,+ flag: "modernSession",+ enabled: true,+ }),+ ).rejects.toMatchObject({ code: "FORBIDDEN" });+ });+});++async function createUser({+ email,+ featureFlags = [],+}: {+ email?: string;+ featureFlags?: string[];+} = {}) {+ const id = randomUUID();+ return prisma.user.create({+ data: {+ id,+ email: email ?? `${id}@example.com`,+ name: `Feature Flag User ${id}`,+ featureFlags,+ },+ });+}++async function createOrganization({+ featureFlagOrgDefaults = [],+}: {+ featureFlagOrgDefaults?: string[];+} = {}) {+ const id = randomUUID();+ return prisma.organization.create({+ data: {+ id: `org-${id}`,+ name: `Feature Flag Org ${id}`,+ featureFlagOrgDefaults,+ },+ });+}++async function prepare(+ plan: Plan = "cloud:core",+ actorRole: Role = Role.OWNER,+ actorIsPlatformAdmin = false,+) {+ const id = randomUUID();+ const org = await createOrganization();+ const project = await prisma.project.create({+ data: {+ id: `project-${id}`,+ orgId: org.id,+ name: `Feature Flag Project ${id}`,+ },+ });+ const actor = await createUser();+ await prisma.organizationMembership.create({+ data: { orgId: org.id, userId: actor.id, role: actorRole },+ });++ const session: Session = {+ expires: "1",+ user: {+ id: actor.id,+ email: actor.email,+ name: actor.name,+ admin: actorIsPlatformAdmin,+ canCreateOrganizations: true,+ featureFlags: {} as NonNullable<Session["user"]>["featureFlags"],+ organizations: [+ {+ id: org.id,+ name: org.name,+ role: actorRole,+ plan,+ cloudConfig: undefined,+ metadata: {},+ aiFeaturesEnabled: false,+ aiTelemetryEnabled: true,+ projects: [+ {+ id: project.id,+ name: project.name,+ role: Role.OWNER,+ deletedAt: null,+ retentionDays: null,+ metadata: {},+ } as NonNullable<+ Session["user"]+ >["organizations"][number]["projects"][number],+ ],+ },+ ],+ },+ environment: {+ enableExperimentalFeatures: false,+ selfHostedInstancePlan: plan,+ },+ };++ const ctx = createInnerTRPCContext({ session, headers: {} });+ return {+ actor,+ caller: appRouter.createCaller({ ...ctx, prisma }),+ org,+ project,+ session,+ };+}diff --git a/web/src/__tests__/server/userAccount.servertest.ts b/web/src/__tests__/server/userAccount.servertest.tsindex 02f1f387dc..d0513106b9 100644--- a/web/src/__tests__/server/userAccount.servertest.ts+++ b/web/src/__tests__/server/userAccount.servertest.ts@@ -6,10 +6,7 @@ import { prisma } from "@langfuse/shared/src/db";import { env } from "@/src/env.mjs";import { appRouter } from "@/src/server/api/root";import { createInnerTRPCContext } from "@/src/server/api/trpc";-import {- getFeaturePreviewOptOutFlag,- parseFlags,-} from "@/src/features/feature-flags/utils";+import { getFeaturePreviewOptOutFlag } from "@/src/features/feature-flags/utils";describe("userAccountRouter.setFeaturePreviewEnabled", () => {const originalCloudRegion = env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION;@@ -22,7 +19,7 @@ describe("userAccountRouter.setFeaturePreviewEnabled", () => {(env as any).NEXT_PUBLIC_LANGFUSE_CLOUD_REGION = originalCloudRegion;});- it("enables the Modern Session preview, leaving other flags intact", async () => {+ it("enables a preview, leaving other flags intact", async () => {const { caller, userId } = await createCaller({featureFlags: ["templateFlag"],});@@ -45,7 +42,7 @@ describe("userAccountRouter.setFeaturePreviewEnabled", () => {expect(user.featureFlags).toEqual(["templateFlag", "modernSession"]);});- it("disables a preview flag without touching the others", async () => {+ it("persists a global opt-out when disabling a preview", async () => {const { caller, userId } = await createCaller({featureFlags: ["templateFlag", "modernSession"],});@@ -65,39 +62,12 @@ describe("userAccountRouter.setFeaturePreviewEnabled", () => {where: { id: userId },select: { featureFlags: true },});- expect(user.featureFlags).toEqual(["templateFlag"]);+ expect(user.featureFlags).toEqual([+ "templateFlag",+ getFeaturePreviewOptOutFlag("modernSession"),+ ]);});- it.each(["langfuse.com", "clickhouse.com"])(- "persists an opt-out when a team member on %s disables a preview",- async (emailDomain) => {- const { caller, userId } = await createCaller({- emailDomain,- featureFlags: ["templateFlag"],- });-- await caller.userAccount.setFeaturePreviewEnabled({- flag: "modernSession",- enabled: false,- });-- const user = await prisma.user.findUniqueOrThrow({- where: { id: userId },- select: { featureFlags: true, email: true },- });- expect(user.featureFlags).toEqual([- "templateFlag",- getFeaturePreviewOptOutFlag("modernSession"),- ]);- expect(- parseFlags(user.featureFlags, {- email: user.email,- v4BetaEnabled: true,- }).modernSession,- ).toBe(false);- },- );-it("rejects enabling in self-hosted deployments", async () => {const { caller } = await createCaller();(env as any).NEXT_PUBLIC_LANGFUSE_CLOUD_REGION = undefined;diff --git a/web/src/components/session/index.tsx b/web/src/components/session/index.tsxindex 418dcdceb5..3aff58ba09 100644--- a/web/src/components/session/index.tsx+++ b/web/src/components/session/index.tsx@@ -837,6 +837,7 @@ const LoadedSessionEventsPage: React.FC<{const capture = usePostHogClientCapture();const isModernSessionEnabled = useIsFeatureEnabled("modernSession", {enableForAdmins: false,+ projectId,});const isMobile = useIsMobile();const parentRef = useRef<HTMLDivElement>(null);diff --git a/web/src/features/feature-flags/README.md b/web/src/features/feature-flags/README.mdindex 1ad697131d..cf9918c220 100644--- a/web/src/features/feature-flags/README.md+++ b/web/src/features/feature-flags/README.md@@ -10,10 +10,17 @@ const isFeatureEnabled = useIsFeatureEnabled("feature-flag-name");When is a feature flag enabled?-1. flag is in user.feature_flags-2. LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES is set-3. user.admin is true+1. `LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES` is set+2. the active project or organization's defaults turn the flag on+3. the user's `feature_flags` contains the flag+4. `user.admin` is true for consumers that keep the admin bypass enabledUser-controlled previews may pass `{ enableForAdmins: false }` so anadministrator can opt in or out like any other user. The deployment-wide`LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES` override still forces flags on.++Organization defaults are evaluated only for the active project or+organization. They are never copied into users and never unioned across all of+a user's memberships. A `feature-preview:<flag>:disabled` entry in+`users.feature_flags` is a global opt-out and wins over every organization+default.diff --git a/web/src/features/feature-flags/available-flags.ts b/web/src/features/feature-flags/available-flags.tsindex 8741544b05..d88ec0063b 100644--- a/web/src/features/feature-flags/available-flags.ts+++ b/web/src/features/feature-flags/available-flags.ts@@ -2,16 +2,25 @@ import { assertUnreachable } from "@langfuse/shared";export const featurePreviewFlags = ["modernSession",- // TODO(remove ~2026-06-19): "searchBar" is retired — the grammar search bar- // is now GA on the v4 events tables for everyone (see useSearchBarEnabled),- // no longer a per-user Feature Preview opt-in. Kept as dead plumbing for a- // safe rollback; drop once the GA rollout is confirmed stable.- "searchBar","compactTimeline",] as const;export type FeaturePreviewFlag = (typeof featurePreviewFlags)[number];+export const isFeaturePreviewFlag = (+ flag: string,+): flag is FeaturePreviewFlag =>+ featurePreviewFlags.some((previewFlag) => previewFlag === flag);++export const filterFeaturePreviewFlags = (+ flags: string[],+): FeaturePreviewFlag[] => flags.filter(isFeaturePreviewFlag);++export const featurePreviewLabels = {+ modernSession: "Compact Session View",+ compactTimeline: "Compact Timeline",+} satisfies Record<FeaturePreviewFlag, string>;+export type FeaturePreviewAvailabilityContext = {v4BetaEnabled: boolean;};@@ -24,10 +33,6 @@ export const isFeaturePreviewAvailable = (return context.v4BetaEnabled;}- if (flag === "searchBar") {- return true;- }-if (flag === "compactTimeline") {return true;}@@ -37,6 +42,7 @@ export const isFeaturePreviewAvailable = (export const availableFlags = [...featurePreviewFlags,+ "searchBar","templateFlag","excludeClickhouseRead","v4BetaToggleVisible",diff --git a/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsx b/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsxnew file mode 100644index 0000000000..5ee5f76282--- /dev/null+++ b/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsx@@ -0,0 +1,238 @@+import { fireEvent, render, screen, waitFor } from "@testing-library/react";+import type { ButtonHTMLAttributes, ReactNode } from "react";++import { OrganizationFeaturePreviewsSettings } from "./OrganizationFeaturePreviewsSettings";++const mocks = vi.hoisted(() => ({+ capture: vi.fn(),+ invalidateDefaults: vi.fn().mockResolvedValue(undefined),+ invalidateMembers: vi.fn().mockResolvedValue(undefined),+ mutate: vi.fn(),+ mutationOptions: undefined as+ | {+ onSuccess?: (+ result: unknown,+ variables: Record<string, unknown>,+ ) => void;+ onError?: (error: Error) => void;+ }+ | undefined,+ experimentalFeaturesEnabled: false,+ userFeatureFlags: {+ modernSession: false,+ compactTimeline: false,+ },+ updateSession: vi.fn().mockResolvedValue(undefined),+}));++vi.mock("next-auth/react", () => ({+ useSession: () => ({+ data: {+ environment: {+ enableExperimentalFeatures: mocks.experimentalFeaturesEnabled,+ },+ user: { featureFlags: mocks.userFeatureFlags },+ },+ update: mocks.updateSession,+ }),+}));++vi.mock("@/src/features/posthog-analytics/usePostHogClientCapture", () => ({+ usePostHogClientCapture: () => mocks.capture,+}));++vi.mock("@/src/features/notifications/showErrorToast", () => ({+ showErrorToast: vi.fn(),+}));++vi.mock("@/src/features/notifications/showSuccessToast", () => ({+ showSuccessToast: vi.fn(),+}));++vi.mock("@/src/components/design-system/Switch/Switch", () => ({+ Switch: ({+ checked,+ disabled,+ onCheckedChange,+ "aria-label": ariaLabel,+ }: {+ checked: boolean;+ disabled: boolean;+ onCheckedChange: (checked: boolean) => void;+ "aria-label": string;+ }) => (+ <input+ aria-label={ariaLabel}+ type="checkbox"+ checked={checked}+ disabled={disabled}+ onChange={(event) => onCheckedChange(event.target.checked)}+ />+ ),+}));++vi.mock("@/src/components/ui/alert-dialog", () => ({+ AlertDialog: ({ children }: { children: ReactNode }) => <>{children}</>,+ AlertDialogContent: ({ children }: { children: ReactNode }) => (+ <div>{children}</div>+ ),+ AlertDialogHeader: ({ children }: { children: ReactNode }) => (+ <div>{children}</div>+ ),+ AlertDialogTitle: ({ children }: { children: ReactNode }) => (+ <h2>{children}</h2>+ ),+ AlertDialogDescription: ({ children }: { children: ReactNode }) => (+ <p>{children}</p>+ ),+ AlertDialogFooter: ({ children }: { children: ReactNode }) => (+ <div>{children}</div>+ ),+ AlertDialogCancel: ({+ children,+ ...props+ }: ButtonHTMLAttributes<HTMLButtonElement>) => (+ <button type="button" {...props}>+ {children}+ </button>+ ),+ AlertDialogAction: ({+ children,+ ...props+ }: ButtonHTMLAttributes<HTMLButtonElement>) => (+ <button type="button" {...props}>+ {children}+ </button>+ ),+}));++vi.mock("@/src/utils/api", () => ({+ api: {+ useUtils: () => ({+ organizations: {+ getFeatureFlagOrgDefaults: { invalidate: mocks.invalidateDefaults },+ },+ members: { allFromOrg: { invalidate: mocks.invalidateMembers } },+ }),+ organizations: {+ getFeatureFlagOrgDefaults: {+ useQuery: () => ({+ data: { defaults: ["modernSession"], memberCount: 3 },+ isError: false,+ isPending: false,+ }),+ },+ setFeatureFlagOrgDefault: {+ useMutation: (options: typeof mocks.mutationOptions) => {+ mocks.mutationOptions = options;+ return { mutate: mocks.mutate, isPending: false };+ },+ },+ },+ },+}));++describe("OrganizationFeaturePreviewsSettings", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ mocks.experimentalFeaturesEnabled = false;+ mocks.userFeatureFlags = {+ modernSession: false,+ compactTimeline: false,+ };+ mocks.mutate.mockImplementation((variables) => {+ mocks.mutationOptions?.onSuccess?.({}, variables);+ });+ });++ it("explains the deployment-wide experimental feature override", () => {+ mocks.experimentalFeaturesEnabled = true;++ render(<OrganizationFeaturePreviewsSettings orgId="org-1" />);++ expect(+ screen.getByText(/experimental features enabled deployment-wide/i),+ ).toBeInTheDocument();+ expect(+ screen.getByText(+ "Every preview on this page is enabled by the env variable LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=true. Per-user opt-outs do not disable these previews.",+ ),+ ).toBeInTheDocument();+ const switches = screen.getAllByRole("checkbox", {+ name: /organization default/i,+ });+ expect(switches).toHaveLength(2);+ switches.forEach((featureSwitch) => {+ expect(featureSwitch).toBeChecked();+ expect(featureSwitch).toBeDisabled();+ });+ });++ it("requires an admin to enable a preview personally before enabling the organization default", () => {+ render(<OrganizationFeaturePreviewsSettings orgId="org-1" />);++ expect(+ screen.getByRole("checkbox", {+ name: "Toggle Compact Timeline organization default",+ }),+ ).toBeDisabled();+ expect(+ screen.getByRole("checkbox", {+ name: "Toggle Compact Session View organization default",+ }),+ ).not.toBeDisabled();+ const personalEnablementRequirements = screen.getAllByText(+ /enable this preview in your personal feature preview settings/i,+ );+ personalEnablementRequirements.forEach((requirement) =>+ expect(requirement).toHaveClass("text-destructive"),+ );+ });++ it("confirms an organization default change and captures metadata once", async () => {+ mocks.userFeatureFlags.compactTimeline = true;+ render(<OrganizationFeaturePreviewsSettings orgId="org-1" />);++ expect(+ screen.getByText(/new members inherit these defaults automatically/i),+ ).toBeInTheDocument();+ fireEvent.click(+ screen.getByRole("checkbox", {+ name: "Toggle Compact Timeline organization default",+ }),+ );+ expect(screen.getByText("Already enabled for you")).toBeInTheDocument();+ expect(+ screen.getByText(/personal Feature Preview settings.*tested/i),+ ).toBeInTheDocument();+ fireEvent.click(screen.getByRole("button", { name: "Confirm" }));++ expect(mocks.mutate).toHaveBeenCalledWith({+ orgId: "org-1",+ flag: "compactTimeline",+ enabled: true,+ });+ await waitFor(() => expect(mocks.capture).toHaveBeenCalledTimes(1));+ expect(mocks.capture).toHaveBeenCalledWith(+ "organization_settings:feature_flag_default_toggled",+ { feature: "compactTimeline", isEnabled: true },+ );+ });++ it("does not capture analytics when a default change fails", () => {+ mocks.userFeatureFlags.compactTimeline = true;+ mocks.mutate.mockImplementation(() => {+ mocks.mutationOptions?.onError?.(new Error("denied"));+ });+ render(<OrganizationFeaturePreviewsSettings orgId="org-1" />);++ fireEvent.click(+ screen.getByRole("checkbox", {+ name: "Toggle Compact Timeline organization default",+ }),+ );+ fireEvent.click(screen.getByRole("button", { name: "Confirm" }));++ expect(mocks.capture).not.toHaveBeenCalled();+ });+});diff --git a/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.tsx b/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.tsxnew file mode 100644index 0000000000..7e8a04c17f--- /dev/null+++ b/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.tsx@@ -0,0 +1,199 @@+import { useState } from "react";+import { useSession } from "next-auth/react";++import Header from "@/src/components/layouts/header";+import { Switch } from "@/src/components/design-system/Switch/Switch";+import {+ AlertDialog,+ AlertDialogAction,+ AlertDialogCancel,+ AlertDialogContent,+ AlertDialogDescription,+ AlertDialogFooter,+ AlertDialogHeader,+ AlertDialogTitle,+} from "@/src/components/ui/alert-dialog";+import { Alert, AlertDescription, AlertTitle } from "@/src/components/ui/alert";+import { Card } from "@/src/components/ui/card";+import {+ featurePreviewFlags,+ featurePreviewLabels,+ type FeaturePreviewFlag,+} from "@/src/features/feature-flags/available-flags";+import { showErrorToast } from "@/src/features/notifications/showErrorToast";+import { showSuccessToast } from "@/src/features/notifications/showSuccessToast";+import { usePostHogClientCapture } from "@/src/features/posthog-analytics/usePostHogClientCapture";+import { api } from "@/src/utils/api";++type ProposedChange = {+ flag: FeaturePreviewFlag;+ enabled: boolean;+};++export function OrganizationFeaturePreviewsSettings({+ orgId,+}: {+ orgId: string;+}) {+ const [proposedChange, setProposedChange] = useState<ProposedChange | null>(+ null,+ );+ const session = useSession();+ const capture = usePostHogClientCapture();+ const utils = api.useUtils();+ const defaultsQuery = api.organizations.getFeatureFlagOrgDefaults.useQuery({+ orgId,+ });+ const updateDefault = api.organizations.setFeatureFlagOrgDefault.useMutation({+ onSuccess: async (_result, variables) => {+ capture("organization_settings:feature_flag_default_toggled", {+ feature: variables.flag,+ isEnabled: variables.enabled,+ });+ setProposedChange(null);+ await Promise.all([+ utils.organizations.getFeatureFlagOrgDefaults.invalidate({ orgId }),+ utils.members.allFromOrg.invalidate(),+ session.update(),+ ]);+ showSuccessToast({+ title: "Feature preview default updated",+ description: `${featurePreviewLabels[variables.flag]} was ${+ variables.enabled ? "enabled" : "disabled"+ } for this organization.`,+ });+ },+ onError: (error) => {+ setProposedChange(null);+ showErrorToast("Failed to update feature preview", error.message);+ },+ });++ if (defaultsQuery.isError) {+ return (+ <Alert variant="destructive">+ <AlertTitle>Feature previews unavailable</AlertTitle>+ <AlertDescription>{defaultsQuery.error.message}</AlertDescription>+ </Alert>+ );+ }++ const selectedDefaults = new Set(defaultsQuery.data?.defaults ?? []);+ const memberCount = defaultsQuery.data?.memberCount ?? 0;+ const experimentalFeaturesEnabled =+ session.data?.environment.enableExperimentalFeatures === true;++ return (+ <div className="flex flex-col gap-4">+ <div>+ <Header title="Feature Previews" />+ <p className="text-muted-foreground text-sm">+ Enable previews for everyone while they are using this organization.+ New members inherit these defaults automatically.+ </p>+ </div>++ {experimentalFeaturesEnabled ? (+ <Alert>+ <AlertTitle>Experimental features enabled deployment-wide</AlertTitle>+ <AlertDescription>+ Every preview on this page is enabled by the env variable+ LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=true. Per-user opt-outs do not+ disable these previews.+ </AlertDescription>+ </Alert>+ ) : null}++ <div className="flex flex-col gap-3">+ {featurePreviewFlags.map((flag) => {+ const selected = selectedDefaults.has(flag);+ const enabledForAdmin =+ session.data?.user?.featureFlags[flag] === true;+ const requiresPersonalEnablement = !selected && !enabledForAdmin;+ return (+ <Card+ key={flag}+ className="flex items-start justify-between gap-6 p-4"+ >+ <div className="flex min-w-0 flex-col gap-1">+ <h3 className="font-bold">{featurePreviewLabels[flag]}</h3>+ {requiresPersonalEnablement ? (+ <p className="text-destructive text-xs">+ Enable this preview in your personal Feature Preview+ settings before enabling it for the organization.+ </p>+ ) : null}+ </div>+ <Switch+ aria-label={`Toggle ${featurePreviewLabels[flag]} organization default`}+ checked={experimentalFeaturesEnabled || selected}+ disabled={+ experimentalFeaturesEnabled ||+ defaultsQuery.isPending ||+ updateDefault.isPending ||+ requiresPersonalEnablement+ }+ onCheckedChange={(enabled) =>+ setProposedChange({ flag, enabled })+ }+ />+ </Card>+ );+ })}+ </div>++ <p className="text-muted-foreground text-xs">+ Defaults apply only in this organization. A user's global personal+ opt-out always wins.+ </p>++ <AlertDialog+ open={proposedChange !== null}+ onOpenChange={(open) => {+ if (!open && !updateDefault.isPending) setProposedChange(null);+ }}+ >+ <AlertDialogContent>+ <AlertDialogHeader>+ <AlertDialogTitle>+ {proposedChange?.enabled ? "Enable" : "Disable"} feature preview?+ </AlertDialogTitle>+ <AlertDialogDescription>+ This will {proposedChange?.enabled ? "enable" : "disable"}{" "}+ {proposedChange+ ? featurePreviewLabels[proposedChange.flag]+ : "this preview"}{" "}+ for up to {memberCount} current member+ {memberCount === 1 ? "" : "s"}. New members inherit enabled+ organization defaults.+ </AlertDialogDescription>+ </AlertDialogHeader>+ {proposedChange?.enabled ? (+ <Alert>+ <AlertTitle>Already enabled for you</AlertTitle>+ <AlertDescription>+ This preview is already enabled in your personal Feature Preview+ settings. Make sure you have tested it before enabling it for+ the organization.+ </AlertDescription>+ </Alert>+ ) : null}+ <AlertDialogFooter>+ <AlertDialogCancel disabled={updateDefault.isPending}>+ Cancel+ </AlertDialogCancel>+ <AlertDialogAction+ disabled={updateDefault.isPending || proposedChange === null}+ onClick={() => {+ if (!proposedChange) return;+ updateDefault.mutate({ orgId, ...proposedChange });+ }}+ >+ Confirm+ </AlertDialogAction>+ </AlertDialogFooter>+ </AlertDialogContent>+ </AlertDialog>+ </div>+ );+}diff --git a/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsx b/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsxnew file mode 100644index 0000000000..2b45d79d1a--- /dev/null+++ b/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsx@@ -0,0 +1,225 @@+import { fireEvent, render, screen, waitFor } from "@testing-library/react";+import type { ComponentProps, ReactNode } from "react";++import { UserFeaturePreviewsControl } from "./UserFeaturePreviewsPopover";++const mocks = vi.hoisted(() => ({+ capture: vi.fn(),+ invalidate: vi.fn().mockResolvedValue(undefined),+ mutate: vi.fn(),+ mutationOptions: undefined as+ | {+ onSuccess?: (+ result: unknown,+ variables: Record<string, unknown>,+ ) => void;+ onError?: (error: Error) => void;+ }+ | undefined,+ updateSession: vi.fn().mockResolvedValue(undefined),+}));++vi.mock("next-auth/react", () => ({+ useSession: () => ({+ data: { user: { id: "actor" } },+ update: mocks.updateSession,+ }),+}));++vi.mock("@/src/features/posthog-analytics/usePostHogClientCapture", () => ({+ usePostHogClientCapture: () => mocks.capture,+}));++vi.mock("@/src/features/notifications/showErrorToast", () => ({+ showErrorToast: vi.fn(),+}));++vi.mock("@/src/features/notifications/showSuccessToast", () => ({+ showSuccessToast: vi.fn(),+}));++vi.mock("@/src/components/ui/popover", () => ({+ Popover: ({ children }: { children: ReactNode }) => <>{children}</>,+ PopoverTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,+ PopoverContent: ({ children }: { children: ReactNode }) => (+ <div>{children}</div>+ ),+}));++vi.mock("@/src/components/ui/hover-card", () => ({+ HoverCard: ({ children }: { children: ReactNode }) => <>{children}</>,+ HoverCardTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,+ HoverCardContent: ({ children }: { children: ReactNode }) => (+ <div>{children}</div>+ ),+}));++vi.mock("@/src/components/design-system/Switch/Switch", () => ({+ Switch: ({+ checked,+ disabled,+ onCheckedChange,+ "aria-label": ariaLabel,+ }: {+ checked: boolean;+ disabled: boolean;+ onCheckedChange: (checked: boolean) => void;+ "aria-label": string;+ }) => (+ <input+ aria-label={ariaLabel}+ type="checkbox"+ checked={checked}+ disabled={disabled}+ onChange={(event) => onCheckedChange(event.target.checked)}+ />+ ),+}));++vi.mock("@/src/utils/api", () => ({+ api: {+ useUtils: () => ({+ members: { allFromOrg: { invalidate: mocks.invalidate } },+ }),+ members: {+ setUserFeaturePreviewEnabled: {+ useMutation: (options: typeof mocks.mutationOptions) => {+ mocks.mutationOptions = options;+ return { mutate: mocks.mutate, isPending: false };+ },+ },+ },+ },+}));++const renderControl = (+ props: Omit<ComponentProps<typeof UserFeaturePreviewsControl>, "children">,+) =>+ render(+ <UserFeaturePreviewsControl {...props}>+ {({ enabledCount, totalCount, content }) => (+ <div>+ <button type="button">+ {enabledCount}/{totalCount} enabled+ </button>+ {content}+ </div>+ )}+ </UserFeaturePreviewsControl>,+ );++describe("UserFeaturePreviewsControl", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ mocks.mutate.mockImplementation((variables) => {+ mocks.mutationOptions?.onSuccess?.({}, variables);+ });+ });++ it("explains why a multi-organization user cannot be changed", () => {+ renderControl({+ orgId: "org-1",+ userId: "user-1",+ featurePreviews: {+ modernSession: false,+ compactTimeline: false,+ },+ management: {+ allowed: false,+ },+ });++ expect(+ screen.getByText(+ "You can only change this user's feature flags if you are an administrator in every organization they belong to.",+ ),+ ).toBeInTheDocument();+ expect(+ screen.getByRole("button", { name: /0\/2 enabled/i }),+ ).toBeDisabled();+ });++ it("updates an eligible user and captures metadata once after success", async () => {+ renderControl({+ orgId: "org-1",+ userId: "user-1",+ featurePreviews: {+ modernSession: false,+ compactTimeline: false,+ },+ management: { allowed: true },+ });++ fireEvent.click(+ screen.getByRole("checkbox", {+ name: "Toggle Compact Timeline for user",+ }),+ );++ expect(mocks.mutate).toHaveBeenCalledWith(+ {+ orgId: "org-1",+ userId: "user-1",+ flag: "compactTimeline",+ enabled: true,+ },+ expect.objectContaining({ onSettled: expect.any(Function) }),+ );+ await waitFor(() => {+ expect(mocks.capture).toHaveBeenCalledTimes(1);+ });+ expect(mocks.capture).toHaveBeenCalledWith(+ "organization_settings:user_feature_flag_toggled",+ { feature: "compactTimeline", isEnabled: true },+ );+ });++ it("keeps pending state isolated to the selected feature", () => {+ mocks.mutate.mockImplementation(() => undefined);+ renderControl({+ orgId: "org-1",+ userId: "user-1",+ featurePreviews: {+ modernSession: false,+ compactTimeline: false,+ },+ management: { allowed: true },+ });++ const compactTimeline = screen.getByRole("checkbox", {+ name: "Toggle Compact Timeline for user",+ });+ const sessions = screen.getByRole("checkbox", {+ name: "Toggle Compact Session View for user",+ });+ fireEvent.click(compactTimeline);++ expect(compactTimeline).toBeDisabled();+ expect(sessions).not.toBeDisabled();+ });++ it("refetches without capturing analytics when the mutation fails", async () => {+ mocks.mutate.mockImplementation((_variables, options) => {+ mocks.mutationOptions?.onError?.(new Error("denied"));+ options.onSettled();+ });+ renderControl({+ orgId: "org-1",+ userId: "user-1",+ featurePreviews: {+ modernSession: false,+ compactTimeline: false,+ },+ management: { allowed: true },+ });++ fireEvent.click(+ screen.getByRole("checkbox", {+ name: "Toggle Compact Timeline for user",+ }),+ );++ await waitFor(() => expect(mocks.invalidate).toHaveBeenCalledOnce());+ expect(mocks.capture).not.toHaveBeenCalled();+ });+});diff --git a/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.tsx b/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.tsxnew file mode 100644index 0000000000..76c3bbfe2b--- /dev/null+++ b/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.tsx@@ -0,0 +1,144 @@+import { useState, type ReactNode } from "react";+import { useSession } from "next-auth/react";++import { Switch } from "@/src/components/design-system/Switch/Switch";+import { Button } from "@/src/components/ui/button";+import {+ HoverCard,+ HoverCardContent,+ HoverCardTrigger,+} from "@/src/components/ui/hover-card";+import { PopoverContent } from "@/src/components/ui/popover";+import {+ featurePreviewFlags,+ featurePreviewLabels,+ type FeaturePreviewFlag,+} from "@/src/features/feature-flags/available-flags";+import { showErrorToast } from "@/src/features/notifications/showErrorToast";+import { showSuccessToast } from "@/src/features/notifications/showSuccessToast";+import { usePostHogClientCapture } from "@/src/features/posthog-analytics/usePostHogClientCapture";+import { api } from "@/src/utils/api";++type FeaturePreviewManagement = {+ allowed: boolean;+};++export function UserFeaturePreviewsControl({+ orgId,+ userId,+ featurePreviews,+ management,+ children,+}: {+ orgId: string;+ userId: string;+ featurePreviews: Record<FeaturePreviewFlag, boolean>;+ management: FeaturePreviewManagement;+ children: (props: {+ enabledCount: number;+ totalCount: number;+ content: ReactNode;+ }) => ReactNode;+}) {+ const session = useSession();+ const [pendingFlags, setPendingFlags] = useState<Set<FeaturePreviewFlag>>(+ new Set(),+ );+ const capture = usePostHogClientCapture();+ const utils = api.useUtils();+ const updatePreview = api.members.setUserFeaturePreviewEnabled.useMutation({+ onSuccess: async (_result, variables) => {+ capture("organization_settings:user_feature_flag_toggled", {+ feature: variables.flag,+ isEnabled: variables.enabled,+ });+ await utils.members.allFromOrg.invalidate();+ if (variables.userId === session.data?.user?.id) {+ await session.update();+ }+ showSuccessToast({+ title: "Feature preview updated",+ description: `${featurePreviewLabels[variables.flag]} was ${+ variables.enabled ? "enabled" : "disabled"+ } for this user.`,+ });+ },+ onError: async () => {+ await utils.members.allFromOrg.invalidate();+ showErrorToast(+ "Failed to update feature preview",+ "Your access may have changed. Refresh and try again.",+ );+ },+ });+ const enabledCount = Object.values(featurePreviews).filter(Boolean).length;+ const totalCount = featurePreviewFlags.length;++ if (!management.allowed) {+ return (+ <HoverCard openDelay={0} closeDelay={0}>+ <HoverCardTrigger asChild>+ <span className="inline-flex cursor-not-allowed">+ <Button variant="outline" size="sm" disabled>+ {enabledCount}/{totalCount} enabled+ </Button>+ </span>+ </HoverCardTrigger>+ <HoverCardContent align="center" side="left">+ <p className="text-xs">+ You can only change this user's feature flags if you are an+ administrator in every organization they belong to.+ </p>+ </HoverCardContent>+ </HoverCard>+ );+ }++ return children({+ enabledCount,+ totalCount,+ content: (+ <PopoverContent align="end" className="w-80">+ <div className="flex flex-col gap-3">+ <div>+ <h4 className="text-sm font-bold">Feature previews</h4>+ <p className="text-muted-foreground text-xs">+ Changes apply to this user in every organization.+ </p>+ </div>+ {featurePreviewFlags.map((flag) => (+ <div key={flag} className="flex items-center justify-between gap-4">+ <span className="text-sm">{featurePreviewLabels[flag]}</span>+ <Switch+ size="sm"+ aria-label={`Toggle ${featurePreviewLabels[flag]} for user`}+ checked={featurePreviews[flag]}+ disabled={pendingFlags.has(flag)}+ onCheckedChange={(enabled) => {+ setPendingFlags((current) => new Set(current).add(flag));+ updatePreview.mutate(+ {+ orgId,+ userId,+ flag,+ enabled,+ },+ {+ onSettled: () => {+ setPendingFlags((current) => {+ const next = new Set(current);+ next.delete(flag);+ return next;+ });+ },+ },+ );+ }}+ />+ </div>+ ))}+ </div>+ </PopoverContent>+ ),+ });+}diff --git a/web/src/features/feature-flags/hooks/useIsFeatureEnabled.ts b/web/src/features/feature-flags/hooks/useIsFeatureEnabled.tsindex 6c7951251f..8f79c8a65d 100644--- a/web/src/features/feature-flags/hooks/useIsFeatureEnabled.ts+++ b/web/src/features/feature-flags/hooks/useIsFeatureEnabled.ts@@ -1,9 +1,18 @@import { useSession } from "next-auth/react";import type { Flag } from "../types";+import { getContextualFeatureFlags } from "../utils";export default function useIsFeatureEnabled(feature: Flag,- { enableForAdmins = true }: { enableForAdmins?: boolean } = {},+ {+ enableForAdmins = true,+ projectId,+ organizationId,+ }: {+ enableForAdmins?: boolean;+ projectId?: string;+ organizationId?: string;+ } = {},): boolean {const session = useSession();@@ -13,7 +22,10 @@ export default function useIsFeatureEnabled(session.data?.environment.enableExperimentalFeatures ?? false;const isFeatureEnabledOnUser =- session.data?.user?.featureFlags[feature] ?? false;+ getContextualFeatureFlags(session.data?.user, {+ projectId,+ organizationId,+ })?.[feature] ?? false;return (isExperimentalFeaturesEnabled ||diff --git a/web/src/features/feature-flags/server/organizationFeatureFlags.ts b/web/src/features/feature-flags/server/organizationFeatureFlags.tsnew file mode 100644index 0000000000..b6f7a8f749--- /dev/null+++ b/web/src/features/feature-flags/server/organizationFeatureFlags.ts@@ -0,0 +1,354 @@+import {+ LangfuseNotFoundError,+ Prisma,+ type PrismaClient,+ Role,+} from "@langfuse/shared";++import {+ filterFeaturePreviewFlags,+ featurePreviewFlags,+ type FeaturePreviewFlag,+} from "@/src/features/feature-flags/available-flags";+import {+ getFeaturePreviewOptOutFlag,+ parseFlagsWithOrganizationDefaults,+} from "@/src/features/feature-flags/utils";++type FeaturePreviewManagementCapability = {+ allowed: boolean;+};++type OrganizationFeaturePreviewStates = Record<FeaturePreviewFlag, boolean>;++export const EMPTY_ORGANIZATION_FEATURE_PREVIEW_STATES = Object.fromEntries(+ featurePreviewFlags.map((flag) => [flag, false]),+) as OrganizationFeaturePreviewStates;++const MAX_SERIALIZABLE_ATTEMPTS = 3;++type FeaturePreviewOverrideState = "inherit" | "enabled" | "disabled";++type FeaturePreviewOverrideChange = {+ before: FeaturePreviewOverrideState;+ after: FeaturePreviewOverrideState;+};++const getFeaturePreviewOverrideState = (+ flags: string[],+ flag: FeaturePreviewFlag,+): FeaturePreviewOverrideState => {+ if (flags.includes(getFeaturePreviewOptOutFlag(flag))) return "disabled";+ if (flags.includes(flag)) return "enabled";+ return "inherit";+};++const pickOrganizationFeaturePreviewStates = (+ flags: ReturnType<typeof parseFlagsWithOrganizationDefaults>,+): OrganizationFeaturePreviewStates =>+ Object.fromEntries(+ featurePreviewFlags.map((flag) => [flag, flags[flag] === true]),+ ) as OrganizationFeaturePreviewStates;++export async function getOrganizationFeaturePreviewStatesByUserId({+ prisma,+ userIds,+ organizationDefaults,+}: {+ prisma: Pick<PrismaClient, "user">;+ userIds: string[];+ organizationDefaults: string[];+}): Promise<Map<string, OrganizationFeaturePreviewStates>> {+ if (userIds.length === 0) return new Map();++ const users = await prisma.user.findMany({+ where: { id: { in: userIds } },+ select: {+ id: true,+ email: true,+ featureFlags: true,+ v4BetaEnabled: true,+ },+ });++ return new Map(+ users.map((user) => [+ user.id,+ pickOrganizationFeaturePreviewStates(+ parseFlagsWithOrganizationDefaults(+ user.featureFlags,+ organizationDefaults,+ {+ email: user.email,+ v4BetaEnabled: user.v4BetaEnabled,+ },+ ),+ ),+ ]),+ );+}++export async function getUserFeaturePreviewManagementCapabilities({+ prisma,+ actorUserId,+ actorIsPlatformAdmin,+ targetUserIds,+ demoOrgId,+}: {+ prisma: Pick<PrismaClient, "organizationMembership">;+ actorUserId: string;+ actorIsPlatformAdmin: boolean;+ targetUserIds: string[];+ demoOrgId?: string;+}): Promise<Map<string, FeaturePreviewManagementCapability>> {+ const uniqueTargetUserIds = [...new Set(targetUserIds)];+ if (actorIsPlatformAdmin) {+ return new Map(+ uniqueTargetUserIds.map((userId) => [+ userId,+ {+ allowed: true,+ } satisfies FeaturePreviewManagementCapability,+ ]),+ );+ }++ const targetMemberships = await prisma.organizationMembership.findMany({+ where: {+ userId: { in: uniqueTargetUserIds },+ ...(demoOrgId ? { orgId: { not: demoOrgId } } : {}),+ },+ select: { userId: true, orgId: true },+ });+ const targetOrgIds = [+ ...new Set(targetMemberships.map((membership) => membership.orgId)),+ ];+ const actorAdminMemberships =+ targetOrgIds.length === 0+ ? []+ : await prisma.organizationMembership.findMany({+ where: {+ userId: actorUserId,+ orgId: { in: targetOrgIds },+ role: { in: [Role.OWNER, Role.ADMIN] },+ },+ select: { orgId: true },+ });+ const actorAdminOrgIds = new Set(+ actorAdminMemberships.map((membership) => membership.orgId),+ );+ const targetOrgIdsByUser = new Map<string, Set<string>>();+ for (const membership of targetMemberships) {+ const orgIds = targetOrgIdsByUser.get(membership.userId) ?? new Set();+ orgIds.add(membership.orgId);+ targetOrgIdsByUser.set(membership.userId, orgIds);+ }++ return new Map(+ uniqueTargetUserIds.map((userId) => {+ const targetOrganizations = targetOrgIdsByUser.get(userId) ?? new Set();+ const allowed = [...targetOrganizations].every((orgId) =>+ actorAdminOrgIds.has(orgId),+ );+ return [+ userId,+ {+ allowed,+ } satisfies FeaturePreviewManagementCapability,+ ];+ }),+ );+}++export async function setUserFeaturePreviewInTransaction({+ tx,+ userId,+ flag,+ enabled,+}: {+ tx: Prisma.TransactionClient;+ userId: string;+ flag: FeaturePreviewFlag;+ enabled: boolean;+}): Promise<FeaturePreviewOverrideChange> {+ const rows = await tx.$queryRaw<+ Array<{+ featureFlags: string[];+ }>+ >`+ SELECT+ feature_flags AS "featureFlags"+ FROM users+ WHERE id = ${userId}+ FOR UPDATE+ `;+ const user = rows[0];+ if (!user) throw new LangfuseNotFoundError("User not found");++ const optOutFlag = getFeaturePreviewOptOutFlag(flag);+ const nextFeatureFlags = user.featureFlags.filter(+ (currentFlag) => currentFlag !== flag && currentFlag !== optOutFlag,+ );+ if (enabled) {+ nextFeatureFlags.push(flag);+ } else {+ nextFeatureFlags.push(optOutFlag);+ }++ const before = getFeaturePreviewOverrideState(user.featureFlags, flag);+ const after = getFeaturePreviewOverrideState(nextFeatureFlags, flag);++ if (+ user.featureFlags.length !== nextFeatureFlags.length ||+ user.featureFlags.some(+ (currentFlag, index) => currentFlag !== nextFeatureFlags[index],+ )+ ) {+ await tx.user.update({+ where: { id: userId },+ data: { featureFlags: { set: nextFeatureFlags } },+ });+ }++ return { before, after };+}++export async function setUserFeaturePreview({+ prisma,+ userId,+ flag,+ enabled,+}: {+ prisma: PrismaClient;+ userId: string;+ flag: FeaturePreviewFlag;+ enabled: boolean;+}): Promise<FeaturePreviewOverrideChange> {+ return withSerializableRetry(prisma, (tx) =>+ setUserFeaturePreviewInTransaction({ tx, userId, flag, enabled }),+ );+}++export async function setUserFeaturePreviewWithAuthorization({+ prisma,+ actorUserId,+ actorIsPlatformAdmin,+ currentOrgId,+ targetUserId,+ flag,+ enabled,+ demoOrgId,+}: {+ prisma: PrismaClient;+ actorUserId: string;+ actorIsPlatformAdmin: boolean;+ currentOrgId: string;+ targetUserId: string;+ flag: FeaturePreviewFlag;+ enabled: boolean;+ demoOrgId?: string;+}): Promise<+ (FeaturePreviewOverrideChange & { membershipId: string }) | undefined+> {+ return withSerializableRetry(prisma, async (tx) => {+ const targetMembership = await tx.organizationMembership.findUnique({+ where: {+ orgId_userId: {+ orgId: currentOrgId,+ userId: targetUserId,+ },+ },+ select: { id: true },+ });+ if (!targetMembership) return undefined;++ const management = await getUserFeaturePreviewManagementCapabilities({+ prisma: tx,+ actorUserId,+ actorIsPlatformAdmin,+ targetUserIds: [targetUserId],+ demoOrgId,+ });+ if (!management.get(targetUserId)?.allowed) return undefined;++ const result = await setUserFeaturePreviewInTransaction({+ tx,+ userId: targetUserId,+ flag,+ enabled,+ });+ return {+ membershipId: targetMembership.id,+ ...result,+ };+ });+}++export async function setOrganizationFeatureFlagDefault({+ prisma,+ orgId,+ flag,+ enabled,+}: {+ prisma: PrismaClient;+ orgId: string;+ flag: FeaturePreviewFlag;+ enabled: boolean;+}): Promise<{+ before: FeaturePreviewFlag[];+ after: FeaturePreviewFlag[];+}> {+ return withSerializableRetry(prisma, async (tx) => {+ const organization = await tx.organization.findUnique({+ where: { id: orgId },+ select: { featureFlagOrgDefaults: true },+ });+ if (!organization) {+ throw new LangfuseNotFoundError("Organization not found");+ }++ const before = filterFeaturePreviewFlags(+ organization.featureFlagOrgDefaults,+ );+ const nextStoredDefaults = organization.featureFlagOrgDefaults.filter(+ (currentFlag) => currentFlag !== flag,+ );+ if (enabled) nextStoredDefaults.push(flag);+ const after = filterFeaturePreviewFlags(nextStoredDefaults);++ await tx.organization.update({+ where: { id: orgId },+ data: { featureFlagOrgDefaults: { set: nextStoredDefaults } },+ });++ return {+ before,+ after,+ };+ });+}++async function withSerializableRetry<T>(+ prisma: PrismaClient,+ operation: (tx: Prisma.TransactionClient) => Promise<T>,+): Promise<T> {+ for (let attempt = 1; attempt <= MAX_SERIALIZABLE_ATTEMPTS; attempt += 1) {+ try {+ return await prisma.$transaction(operation, {+ isolationLevel: Prisma.TransactionIsolationLevel.Serializable,+ });+ } catch (error) {+ if (+ !(+ error instanceof Prisma.PrismaClientKnownRequestError &&+ error.code === "P2034" &&+ attempt < MAX_SERIALIZABLE_ATTEMPTS+ )+ ) {+ throw error;+ }+ }+ }++ throw new Error("Serializable transaction retry exhausted");+}diff --git a/web/src/features/feature-flags/utils.clienttest.ts b/web/src/features/feature-flags/utils.clienttest.tsindex 175dc163a1..0a49761cb2 100644--- a/web/src/features/feature-flags/utils.clienttest.ts+++ b/web/src/features/feature-flags/utils.clienttest.ts@@ -2,7 +2,12 @@import { describe, expect, it } from "vitest";-import { getFeaturePreviewOptOutFlag, parseFlags } from "./utils";+import {+ getContextualFeatureFlags,+ getFeaturePreviewOptOutFlag,+ parseFlags,+ parseFlagsWithOrganizationDefaults,+} from "./utils";describe("parseFlags", () => {it("enables feature previews by default for Langfuse team members", () => {@@ -12,7 +17,6 @@ describe("parseFlags", () => {});expect(flags.modernSession).toBe(true);- expect(flags.searchBar).toBe(true);expect(flags.compactTimeline).toBe(true);});@@ -23,7 +27,6 @@ describe("parseFlags", () => {});expect(flags.modernSession).toBe(true);- expect(flags.searchBar).toBe(true);expect(flags.compactTimeline).toBe(true);});@@ -34,7 +37,6 @@ describe("parseFlags", () => {});expect(flags.modernSession).toBe(false);- expect(flags.searchBar).toBe(false);expect(flags.compactTimeline).toBe(false);});@@ -45,8 +47,71 @@ describe("parseFlags", () => {});expect(flags.modernSession).toBe(false);- expect(flags.searchBar).toBe(true);// Opting out of one preview leaves the others alone.expect(flags.compactTimeline).toBe(true);});++ it("honors an explicit opt-out for every user", () => {+ const flags = parseFlags(+ ["modernSession", getFeaturePreviewOptOutFlag("modernSession")],+ {+ email: "[email protected]",+ v4BetaEnabled: true,+ },+ );++ expect(flags.modernSession).toBe(false);+ });++ it("applies organization defaults without overriding a global opt-out", () => {+ const enabled = parseFlagsWithOrganizationDefaults(+ [],+ ["compactTimeline"],+ { email: "[email protected]", v4BetaEnabled: true },+ );+ const optedOut = parseFlagsWithOrganizationDefaults(+ [getFeaturePreviewOptOutFlag("compactTimeline")],+ ["compactTimeline"],+ { email: "[email protected]", v4BetaEnabled: true },+ );++ expect(enabled.compactTimeline).toBe(true);+ expect(optedOut.compactTimeline).toBe(false);+ });++ it("selects flags from only the active project organization", () => {+ const personalFlags = parseFlags([], {+ email: "[email protected]",+ v4BetaEnabled: true,+ });+ const enabledInFirstOrg = { ...personalFlags, compactTimeline: true };+ const user = {+ featureFlags: personalFlags,+ organizations: [+ {+ id: "org-a",+ featureFlags: enabledInFirstOrg,+ projects: [{ id: "project-a" }],+ },+ {+ id: "org-b",+ featureFlags: personalFlags,+ projects: [{ id: "project-b" }],+ },+ ],+ };++ expect(+ getContextualFeatureFlags(user, { projectId: "project-a" })+ ?.compactTimeline,+ ).toBe(true);+ expect(+ getContextualFeatureFlags(user, { projectId: "project-b" })+ ?.compactTimeline,+ ).toBe(false);+ expect(+ getContextualFeatureFlags(user, { organizationId: "org-a" })+ ?.compactTimeline,+ ).toBe(true);+ });});diff --git a/web/src/features/feature-flags/utils.ts b/web/src/features/feature-flags/utils.tsindex 4402adc8d5..08f1f97168 100644--- a/web/src/features/feature-flags/utils.ts+++ b/web/src/features/feature-flags/utils.ts@@ -1,17 +1,13 @@import {availableFlags,- featurePreviewFlags,+ filterFeaturePreviewFlags,+ isFeaturePreviewFlag,isFeaturePreviewAvailable,type FeaturePreviewAvailabilityContext,type FeaturePreviewFlag,} from "./available-flags";import { type Flags } from "./types";-const isFeaturePreviewFlag = (- flag: (typeof availableFlags)[number],-): flag is FeaturePreviewFlag =>- featurePreviewFlags.some((previewFlag) => previewFlag === flag);-export const getFeaturePreviewOptOutFlag = (flag: FeaturePreviewFlag) =>`feature-preview:${flag}:disabled`;@@ -37,12 +33,20 @@ export const parseFlags = ();availableFlags.forEach((flag) => {+ if (+ isFeaturePreviewFlag(flag) &&+ dbFlags.includes(getFeaturePreviewOptOutFlag(flag))+ ) {+ parsedFlags[flag] = false;+ return;+ }+if (enableFeaturePreviewsByDefault &&isFeaturePreviewFlag(flag) &&isFeaturePreviewAvailable(flag, context)) {- parsedFlags[flag] = !dbFlags.includes(getFeaturePreviewOptOutFlag(flag));+ parsedFlags[flag] = true;return;}@@ -51,3 +55,45 @@ export const parseFlags = (return parsedFlags;};++export const parseFlagsWithOrganizationDefaults = (+ dbFlags: string[],+ organizationDefaults: string[],+ context: FeaturePreviewAvailabilityContext & {+ email: string | null | undefined;+ },+): Flags => {+ const featurePreviewDefaults =+ filterFeaturePreviewFlags(organizationDefaults);++ return parseFlags(dbFlags.concat(featurePreviewDefaults), context);+};++type ContextualFeatureFlagUser = {+ featureFlags: Flags;+ organizations: Array<{+ id: string;+ featureFlags?: Flags;+ projects: Array<{ id: string }>;+ }>;+};++export const getContextualFeatureFlags = (+ user: ContextualFeatureFlagUser | null | undefined,+ {+ projectId,+ organizationId,+ }: { projectId?: string; organizationId?: string } = {},+): Flags | undefined => {+ if (!user) return undefined;++ const organization = organizationId+ ? user.organizations.find((candidate) => candidate.id === organizationId)+ : projectId+ ? user.organizations.find((candidate) =>+ candidate.projects.some((project) => project.id === projectId),+ )+ : undefined;++ return organization?.featureFlags ?? user.featureFlags;+};diff --git a/web/src/features/feature-previews/assets/filter-search-bar-dark.svg b/web/src/features/feature-previews/assets/filter-search-bar-dark.svgdeleted file mode 100644index 576c731f43..0000000000--- a/web/src/features/feature-previews/assets/filter-search-bar-dark.svg+++ /dev/null@@ -1,107 +0,0 @@-<svg xmlns="http://www.w3.org/2000/svg" width="650" height="300" viewBox="0 0 650 300">- <defs>- <linearGradient id="barGlow" x1="62" y1="52" x2="595" y2="104" gradientUnits="userSpaceOnUse">- <stop offset="0" stop-color="hsl(246, 55%, 70%)" stop-opacity="0.14"/>- <stop offset="0.58" stop-color="hsl(217.2, 32.6%, 18%)" stop-opacity="0.72"/>- <stop offset="1" stop-color="hsl(188, 53%, 63%)" stop-opacity="0.08"/>- </linearGradient>- <linearGradient id="rowGlow" x1="255" y1="173" x2="574" y2="196" gradientUnits="userSpaceOnUse">- <stop offset="0" stop-color="hsl(246, 55%, 70%)" stop-opacity="0.2"/>- <stop offset="1" stop-color="hsl(217.2, 32.6%, 16%)" stop-opacity="0.74"/>- </linearGradient>- </defs>-- <rect width="650" height="300" fill="hsl(222.2, 84%, 4.9%)"/>-- <g stroke="hsl(210, 40%, 83%)" stroke-width="1.5" fill="none" opacity="0.4">- <path d="M14 32 V14 H32"/>- <path d="M636 32 V14 H618"/>- <path d="M14 268 V286 H32"/>- <path d="M636 268 V286 H618"/>- </g>-- <g opacity="0.22" fill="none" stroke="hsl(217.2, 32.6%, 36%)" stroke-width="1">- <path d="M83 41 L584 40 L610 77 L560 118 L118 110 L55 76 Z"/>- <path d="M153 41 L124 111"/>- <path d="M321 41 L304 109"/>- <path d="M476 40 L514 113"/>- </g>-- <rect x="48" y="54" width="554" height="54" rx="10" fill="url(#barGlow)" stroke="hsl(217.2, 32.6%, 30%)"/>- <polygon points="87,60 158,54 133,108 63,104" fill="hsl(246, 55%, 70%)" fill-opacity="0.06"/>- <polygon points="420,54 589,54 559,108 455,108" fill="hsl(188, 53%, 63%)" fill-opacity="0.05"/>-- <circle cx="77" cy="78" r="7" fill="none" stroke="hsl(210, 40%, 83%)" stroke-width="2.2"/>- <path d="M82 83 L90 91" stroke="hsl(210, 40%, 83%)" stroke-width="2.2" stroke-linecap="round"/>-- <g font-family="'Geist Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace" font-size="12" font-weight="600" letter-spacing="0.01em" text-anchor="middle">- <rect x="112" y="69" width="108" height="25" rx="6" fill="hsl(246, 55%, 70%)" fill-opacity="0.16" stroke="hsl(246, 55%, 70%)" stroke-opacity="0.8"/>- <text x="166" y="86" fill="hsl(246, 72%, 85%)">level<tspan fill-opacity="0.5">:</tspan>ERROR</text>-- <rect x="230" y="69" width="86" height="25" rx="6" fill="hsl(217.2, 32.6%, 17.5%)" stroke="hsl(217.2, 32.6%, 36%)"/>- <text x="273" y="86" fill="hsl(210, 40%, 86%)">env<tspan fill-opacity="0.5">:</tspan>prod</text>-- <rect x="326" y="69" width="100" height="25" rx="6" fill="hsl(217.2, 32.6%, 17.5%)" stroke="hsl(217.2, 32.6%, 36%)"/>- <text x="376" y="86" fill="hsl(210, 40%, 86%)">latency<tspan fill-opacity="0.5">></tspan>2s</text>-- <rect x="436" y="69" width="86" height="25" rx="6" fill="hsl(217.2, 32.6%, 17.5%)" stroke="hsl(217.2, 32.6%, 36%)"/>- <text x="479" y="86" fill="hsl(210, 40%, 86%)">score<tspan fill-opacity="0.5">></tspan>.8</text>-- <rect x="534" y="75" width="3" height="18" rx="1.5" fill="hsl(210, 40%, 83%)" opacity="0.85"/>- </g>-- <g stroke="hsl(210, 40%, 83%)" stroke-width="1" stroke-dasharray="3 6" opacity="0.28" fill="none">- <path d="M166 108 C 156 124, 139 135, 122 151"/>- <path d="M273 108 C 277 129, 269 145, 274 165"/>- <path d="M376 108 C 393 133, 411 149, 452 167"/>- <path d="M479 108 C 487 131, 506 148, 540 168"/>- </g>-- <g font-family="'Geist Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace">- <rect x="54" y="135" width="160" height="115" rx="8" fill="hsl(222.2, 84%, 4.9%)" stroke="hsl(217.2, 32.6%, 29%)"/>- <polygon points="54,135 214,135 183,169 72,176" fill="hsl(217.2, 32.6%, 15%)" fill-opacity="0.4"/>- <path d="M86 135 L122 250" stroke="hsl(217.2, 32.6%, 28%)" opacity="0.6"/>- <path d="M183 135 L154 250" stroke="hsl(217.2, 32.6%, 24%)" opacity="0.6"/>-- <text x="72" y="156" font-size="9.5" font-weight="600" letter-spacing="0.16em" fill="hsl(215, 20.2%, 62%)">FILTER FIELD</text>- <line x1="72" y1="168" x2="194" y2="168" stroke="hsl(217.2, 32.6%, 27.5%)"/>-- <circle cx="82" cy="194" r="4" fill="hsl(246, 55%, 70%)"/>- <text x="100" y="198" font-size="12" font-weight="500" fill="hsl(210, 40%, 86%)">level</text>- <polygon points="150,184 190,184 198,204 155,204" fill="hsl(246, 55%, 70%)" fill-opacity="0.16" stroke="hsl(246, 55%, 70%)" stroke-opacity="0.68"/>- <text x="173" y="198" font-size="10" font-weight="600" letter-spacing="0.04em" text-anchor="middle" fill="hsl(246, 72%, 85%)">ERR</text>-- <circle cx="82" cy="228" r="4" fill="hsl(215, 20.2%, 55%)"/>- <text x="100" y="232" font-size="12" font-weight="500" fill="hsl(215, 20.2%, 66%)">environment</text>- </g>-- <g font-family="'Geist Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace">- <rect x="244" y="135" width="352" height="115" rx="8" fill="hsl(222.2, 84%, 4.9%)" stroke="hsl(217.2, 32.6%, 29%)"/>- <polygon points="244,135 596,135 574,167 256,171" fill="hsl(217.2, 32.6%, 15%)" fill-opacity="0.34"/>- <path d="M430 135 L406 250" stroke="hsl(217.2, 32.6%, 25%)" opacity="0.6"/>- <path d="M550 135 L525 250" stroke="hsl(217.2, 32.6%, 24%)" opacity="0.6"/>-- <text x="266" y="156" font-size="9.5" font-weight="600" letter-spacing="0.16em" fill="hsl(215, 20.2%, 62%)">MATCHED TRACE</text>- <line x1="266" y1="168" x2="574" y2="168" stroke="hsl(217.2, 32.6%, 27.5%)"/>-- <path d="M262 180 H574 L566 208 H262 Z" fill="url(#rowGlow)" stroke="hsl(246, 55%, 70%)" stroke-opacity="0.7"/>- <rect x="262" y="217" width="304" height="22" rx="5" fill="hsl(222.2, 84%, 4.9%)" stroke="hsl(217.2, 32.6%, 28%)"/>-- <circle cx="282" cy="194" r="4" fill="hsl(246, 55%, 70%)"/>- <text x="302" y="198" font-size="12" font-weight="500" fill="hsl(210, 40%, 87%)">checkout-flow</text>- <text x="434" y="198" font-size="12" font-weight="600" fill="hsl(246, 72%, 85%)">ERROR</text>- <text x="502" y="198" font-size="12" font-weight="500" fill="hsl(210, 40%, 80%)">2.4s</text>- <polygon points="544,187 572,187 568,203 540,203" fill="hsl(246, 55%, 70%)" fill-opacity="0.22"/>- <text x="556" y="198" font-size="10.5" font-weight="600" letter-spacing="0.02em" text-anchor="middle" fill="hsl(246, 72%, 85%)">.91</text>-- <circle cx="282" cy="228" r="3.5" fill="hsl(215, 20.2%, 55%)"/>- <text x="302" y="232" font-size="12" font-weight="500" fill="hsl(215, 20.2%, 66%)">refund-agent</text>- <text x="434" y="232" font-size="12" font-weight="500" fill="hsl(215, 20.2%, 62%)">WARN</text>- <text x="502" y="232" font-size="12" font-weight="500" fill="hsl(215, 20.2%, 62%)">1.7s</text>- </g>-- <g opacity="0.72">- <path d="M214 195 C 226 194, 234 192, 244 190" stroke="hsl(246, 55%, 70%)" stroke-dasharray="3 5" fill="none"/>- <circle cx="214" cy="195" r="3.5" fill="hsl(246, 55%, 70%)"/>- </g>-</svg>diff --git a/web/src/features/feature-previews/assets/filter-search-bar-light.svg b/web/src/features/feature-previews/assets/filter-search-bar-light.svgdeleted file mode 100644index c80d33b199..0000000000--- a/web/src/features/feature-previews/assets/filter-search-bar-light.svg+++ /dev/null@@ -1,107 +0,0 @@-<svg xmlns="http://www.w3.org/2000/svg" width="650" height="300" viewBox="0 0 650 300">- <defs>- <linearGradient id="barGlow" x1="62" y1="52" x2="595" y2="104" gradientUnits="userSpaceOnUse">- <stop offset="0" stop-color="hsl(243, 75.4%, 58.6%)" stop-opacity="0.14"/>- <stop offset="0.58" stop-color="hsl(210, 40%, 94%)" stop-opacity="0.72"/>- <stop offset="1" stop-color="hsl(188, 60%, 42%)" stop-opacity="0.08"/>- </linearGradient>- <linearGradient id="rowGlow" x1="255" y1="173" x2="574" y2="196" gradientUnits="userSpaceOnUse">- <stop offset="0" stop-color="hsl(243, 75.4%, 58.6%)" stop-opacity="0.2"/>- <stop offset="1" stop-color="hsl(210, 40%, 95%)" stop-opacity="0.74"/>- </linearGradient>- </defs>-- <rect width="650" height="300" fill="hsl(0, 0%, 100%)"/>-- <g stroke="hsl(222.2, 47.4%, 11.2%)" stroke-width="1.5" fill="none" opacity="0.4">- <path d="M14 32 V14 H32"/>- <path d="M636 32 V14 H618"/>- <path d="M14 268 V286 H32"/>- <path d="M636 268 V286 H618"/>- </g>-- <g opacity="0.22" fill="none" stroke="hsl(214.3, 31.8%, 82%)" stroke-width="1">- <path d="M83 41 L584 40 L610 77 L560 118 L118 110 L55 76 Z"/>- <path d="M153 41 L124 111"/>- <path d="M321 41 L304 109"/>- <path d="M476 40 L514 113"/>- </g>-- <rect x="48" y="54" width="554" height="54" rx="10" fill="url(#barGlow)" stroke="hsl(214.3, 31.8%, 86%)"/>- <polygon points="87,60 158,54 133,108 63,104" fill="hsl(243, 75.4%, 58.6%)" fill-opacity="0.06"/>- <polygon points="420,54 589,54 559,108 455,108" fill="hsl(188, 60%, 42%)" fill-opacity="0.05"/>-- <circle cx="77" cy="78" r="7" fill="none" stroke="hsl(222.2, 47.4%, 11.2%)" stroke-width="2.2"/>- <path d="M82 83 L90 91" stroke="hsl(222.2, 47.4%, 11.2%)" stroke-width="2.2" stroke-linecap="round"/>-- <g font-family="'Geist Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace" font-size="12" font-weight="600" letter-spacing="0.01em" text-anchor="middle">- <rect x="112" y="69" width="108" height="25" rx="6" fill="hsl(243, 75.4%, 58.6%)" fill-opacity="0.16" stroke="hsl(243, 75.4%, 58.6%)" stroke-opacity="0.8"/>- <text x="166" y="86" fill="hsl(243, 75.4%, 45%)">level<tspan fill-opacity="0.5">:</tspan>ERROR</text>-- <rect x="230" y="69" width="86" height="25" rx="6" fill="hsl(210, 40%, 96.1%)" stroke="hsl(214.3, 31.8%, 82%)"/>- <text x="273" y="86" fill="hsl(222.2, 47.4%, 11.2%)">env<tspan fill-opacity="0.5">:</tspan>prod</text>-- <rect x="326" y="69" width="100" height="25" rx="6" fill="hsl(210, 40%, 96.1%)" stroke="hsl(214.3, 31.8%, 82%)"/>- <text x="376" y="86" fill="hsl(222.2, 47.4%, 11.2%)">latency<tspan fill-opacity="0.5">></tspan>2s</text>-- <rect x="436" y="69" width="86" height="25" rx="6" fill="hsl(210, 40%, 96.1%)" stroke="hsl(214.3, 31.8%, 82%)"/>- <text x="479" y="86" fill="hsl(222.2, 47.4%, 11.2%)">score<tspan fill-opacity="0.5">></tspan>.8</text>-- <rect x="534" y="75" width="3" height="18" rx="1.5" fill="hsl(222.2, 47.4%, 11.2%)" opacity="0.85"/>- </g>-- <g stroke="hsl(222.2, 47.4%, 11.2%)" stroke-width="1" stroke-dasharray="3 6" opacity="0.28" fill="none">- <path d="M166 108 C 156 124, 139 135, 122 151"/>- <path d="M273 108 C 277 129, 269 145, 274 165"/>- <path d="M376 108 C 393 133, 411 149, 452 167"/>- <path d="M479 108 C 487 131, 506 148, 540 168"/>- </g>-- <g font-family="'Geist Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace">- <rect x="54" y="135" width="160" height="115" rx="8" fill="hsl(0, 0%, 100%)" stroke="hsl(214.3, 31.8%, 88%)"/>- <polygon points="54,135 214,135 183,169 72,176" fill="hsl(210, 40%, 96.1%)" fill-opacity="0.4"/>- <path d="M86 135 L122 250" stroke="hsl(214.3, 31.8%, 91.4%)" opacity="0.6"/>- <path d="M183 135 L154 250" stroke="hsl(214.3, 31.8%, 88%)" opacity="0.6"/>-- <text x="72" y="156" font-size="9.5" font-weight="600" letter-spacing="0.16em" fill="hsl(215.4, 16.3%, 46.9%)">FILTER FIELD</text>- <line x1="72" y1="168" x2="194" y2="168" stroke="hsl(214.3, 31.8%, 91.4%)"/>-- <circle cx="82" cy="194" r="4" fill="hsl(243, 75.4%, 58.6%)"/>- <text x="100" y="198" font-size="12" font-weight="500" fill="hsl(222.2, 47.4%, 11.2%)">level</text>- <polygon points="150,184 190,184 198,204 155,204" fill="hsl(243, 75.4%, 58.6%)" fill-opacity="0.16" stroke="hsl(243, 75.4%, 58.6%)" stroke-opacity="0.68"/>- <text x="173" y="198" font-size="10" font-weight="600" letter-spacing="0.04em" text-anchor="middle" fill="hsl(243, 75.4%, 45%)">ERR</text>-- <circle cx="82" cy="228" r="4" fill="hsl(215.4, 16.3%, 55%)"/>- <text x="100" y="232" font-size="12" font-weight="500" fill="hsl(215.4, 16.3%, 46.9%)">environment</text>- </g>-- <g font-family="'Geist Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace">- <rect x="244" y="135" width="352" height="115" rx="8" fill="hsl(0, 0%, 100%)" stroke="hsl(214.3, 31.8%, 88%)"/>- <polygon points="244,135 596,135 574,167 256,171" fill="hsl(210, 40%, 96.1%)" fill-opacity="0.34"/>- <path d="M430 135 L406 250" stroke="hsl(214.3, 31.8%, 88%)" opacity="0.6"/>- <path d="M550 135 L525 250" stroke="hsl(214.3, 31.8%, 88%)" opacity="0.6"/>-- <text x="266" y="156" font-size="9.5" font-weight="600" letter-spacing="0.16em" fill="hsl(215.4, 16.3%, 46.9%)">MATCHED TRACE</text>- <line x1="266" y1="168" x2="574" y2="168" stroke="hsl(214.3, 31.8%, 91.4%)"/>-- <path d="M262 180 H574 L566 208 H262 Z" fill="url(#rowGlow)" stroke="hsl(243, 75.4%, 58.6%)" stroke-opacity="0.7"/>- <rect x="262" y="217" width="304" height="22" rx="5" fill="hsl(0, 0%, 100%)" stroke="hsl(214.3, 31.8%, 91.4%)"/>-- <circle cx="282" cy="194" r="4" fill="hsl(243, 75.4%, 58.6%)"/>- <text x="302" y="198" font-size="12" font-weight="500" fill="hsl(222.2, 84%, 4.9%)">checkout-flow</text>- <text x="434" y="198" font-size="12" font-weight="600" fill="hsl(243, 75.4%, 45%)">ERROR</text>- <text x="502" y="198" font-size="12" font-weight="500" fill="hsl(215.4, 16.3%, 35%)">2.4s</text>- <polygon points="544,187 572,187 568,203 540,203" fill="hsl(243, 75.4%, 58.6%)" fill-opacity="0.22"/>- <text x="556" y="198" font-size="10.5" font-weight="600" letter-spacing="0.02em" text-anchor="middle" fill="hsl(243, 75.4%, 45%)">.91</text>-- <circle cx="282" cy="228" r="3.5" fill="hsl(215.4, 16.3%, 55%)"/>- <text x="302" y="232" font-size="12" font-weight="500" fill="hsl(215.4, 16.3%, 46.9%)">refund-agent</text>- <text x="434" y="232" font-size="12" font-weight="500" fill="hsl(215.4, 16.3%, 46.9%)">WARN</text>- <text x="502" y="232" font-size="12" font-weight="500" fill="hsl(215.4, 16.3%, 46.9%)">1.7s</text>- </g>-- <g opacity="0.72">- <path d="M214 195 C 226 194, 234 192, 244 190" stroke="hsl(243, 75.4%, 58.6%)" stroke-dasharray="3 5" fill="none"/>- <circle cx="214" cy="195" r="3.5" fill="hsl(243, 75.4%, 58.6%)"/>- </g>-</svg>diff --git a/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx b/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsxindex 9e49d499ca..e7c1f4e3c7 100644--- a/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx+++ b/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx@@ -4,6 +4,7 @@ import { showSuccessToast } from "@/src/features/notifications/showSuccessToast"import { usePostHogClientCapture } from "@/src/features/posthog-analytics/usePostHogClientCapture";import { useV4Beta } from "@/src/features/events/hooks/useV4Beta";import { V4_PREVIEW_LABEL } from "@/src/features/events/lib/v4PreviewLabel";+import { featurePreviewLabels } from "@/src/features/feature-flags/available-flags";import { api } from "@/src/utils/api";import {@@ -17,12 +18,6 @@ type ControlledFeaturePreviewModalProps = {onOpenChange: (open: boolean) => void;};-const PREVIEW_LABEL: Record<PreviewFlag, string> = {- modernSession: "Compact Session View",- searchBar: "Filter Search Bar",- compactTimeline: "Compact Timeline",-};-export function ControlledFeaturePreviewModal({open,onOpenChange,@@ -40,9 +35,7 @@ export function ControlledFeaturePreviewModal({});showSuccessToast({title: "Feature preview updated",- description: `${PREVIEW_LABEL[variables.flag]} preview has been ${- variables.enabled ? "enabled" : "disabled"- }.`,+ description: `${featurePreviewLabels[variables.flag]} preview has been ${variables.enabled ? "enabled" : "disabled"}.`,});},onError: (error) => {@@ -82,14 +75,6 @@ export function ControlledFeaturePreviewModal({onToggle: onToggle("compactTimeline"),isToggling: setFeaturePreviewEnabled.isPending,},- // The "Filter Search Bar" preview is retired — the bar is now generally- // available on the v4 events tables for everyone (see useSearchBarEnabled),- // so it no longer renders a tile here. The `searchBar` flag plumbing- // (PreviewFlag type, registry entry, the userAccount allowlist) is kept for- // now so a rollback is a one-line revert; restore the `searchBar: { ... }`- // state entry to bring the tile back.- // TODO(remove ~2026-06-19): delete the dead searchBar plumbing once the GA- // rollout is confirmed stable — see useSearchBarEnabled for the full list.};return (diff --git a/web/src/features/feature-previews/components/FeaturePreviewModal.tsx b/web/src/features/feature-previews/components/FeaturePreviewModal.tsxindex 848360dd42..8a3945dfb2 100644--- a/web/src/features/feature-previews/components/FeaturePreviewModal.tsx+++ b/web/src/features/feature-previews/components/FeaturePreviewModal.tsx@@ -12,20 +12,18 @@ import {import { Switch } from "@/src/components/design-system/Switch/Switch";import { Button } from "@/src/components/ui/button";import { cn } from "@/src/utils/tailwind";-import type { FeaturePreviewFlag } from "@/src/features/feature-flags/available-flags";+import {+ featurePreviewLabels,+ type FeaturePreviewFlag,+} from "@/src/features/feature-flags/available-flags";-import filterSearchBarDarkIllustration from "../assets/filter-search-bar-dark.svg";-import filterSearchBarLightIllustration from "../assets/filter-search-bar-light.svg";import compactTimelineDarkIllustration from "../assets/compact-timeline-dark.svg";import compactTimelineLightIllustration from "../assets/compact-timeline-light.svg";import modernSessionDarkIllustration from "../assets/modern-session-dark.svg";import modernSessionLightIllustration from "../assets/modern-session-light.svg";/** Flags the Feature Preview modal can toggle. Keep in sync with the- * userAccount.setFeaturePreviewEnabled allowlist and available-flags.ts.- * `searchBar` is retired and no longer renders a tile — see- * ControlledFeaturePreviewModal. It remains as rollback plumbing.- * TODO(remove ~2026-06-19): drop "searchBar" once GA is confirmed. */+ * userAccount.setFeaturePreviewEnabled allowlist and available-flags.ts. */export type PreviewFlag = FeaturePreviewFlag;type PreviewIllustration = {@@ -38,8 +36,6 @@ type PreviewIllustration = {type PreviewRegistryItem = {flag: PreviewFlag;- title: string;- sidebarLabel: string;description: string;details: string;feedbackUrl: string;@@ -61,8 +57,6 @@ export type PreviewState = {const PREVIEW_REGISTRY: PreviewRegistryItem[] = [{flag: "modernSession",- title: "Compact Session View",- sidebarLabel: "Compact Session View",description:"Navigate every trace in a session from one continuous conversation feed, with tools and structured data available on demand.",details:@@ -76,8 +70,6 @@ const PREVIEW_REGISTRY: PreviewRegistryItem[] = [},{flag: "compactTimeline",- title: "Compact Timeline",- sidebarLabel: "Compact Timeline",description:"See a whole trace at once — every observation a single dense line, coloured by type — then zoom and pan it like a map.",details:@@ -89,25 +81,6 @@ const PREVIEW_REGISTRY: PreviewRegistryItem[] = [alt: "A whole trace as dense coloured lines, one per observation, cascading across a time axis.",},},- // TODO(remove ~2026-06-19): dead registry entry — "searchBar" is GA on the v4- // events tables and no longer surfaced in the dialog (no state entry in- // ControlledFeaturePreviewModal), so this is filtered out and never renders.- // Kept for a safe rollback; delete with the rest of the searchBar plumbing.- {- flag: "searchBar",- title: "Filter Search Bar",- sidebarLabel: "Filter Search Bar",- description:- "A keyboard-driven query bar on the Observations and Traces tables — type filters like level:ERROR -env:dev latency:>2 with inline suggestions, alongside the existing filter sidebar.",- details:- "The search bar lets you build and edit filters by typing a compact query language with autocomplete, instead of clicking through the sidebar. It stays in sync with the sidebar (both read and write the same filter state) and supports field filters, comparisons, any-of groups, negation, metadata/score paths, and full-text search across input/output. It is available on the new (v4) Observations and Traces tables.",- feedbackUrl: "https://github.com/orgs/langfuse/discussions/14196",- illustration: {- light: filterSearchBarLightIllustration,- dark: filterSearchBarDarkIllustration,- alt: "The filter search bar turns typed queries like level:ERROR -env:dev into Observations and Traces table filters with inline suggestions.",- },- },];const FEATURE_PREVIEW_MODAL_TITLE = "Feature Preview";@@ -171,7 +144,7 @@ export function FeaturePreviewModal({><span className="min-w-0"><span className="block text-sm font-bold">- {item.sidebarLabel}+ {featurePreviewLabels[item.flag]}</span><span className="text-muted-foreground mt-1 line-clamp-2 block text-xs">{state[item.flag]?.disabled@@ -199,7 +172,7 @@ export function FeaturePreviewModal({<div className="flex items-start justify-between gap-6"><div><h2 className="text-foreground text-xl font-bold">- {selected.title}+ {featurePreviewLabels[selected.flag]}</h2><p className="text-muted-foreground mt-2 max-w-2xl text-sm leading-5">{selected.description}@@ -222,7 +195,7 @@ export function FeaturePreviewModal({selectedState.isToggling === true}onCheckedChange={selectedState.onToggle}- aria-label={`Toggle ${selected.title}`}+ aria-label={`Toggle ${featurePreviewLabels[selected.flag]}`}/></div></div>diff --git a/web/src/features/organizations/server/organizationRouter.ts b/web/src/features/organizations/server/organizationRouter.tsindex 5dc49c53a9..590b708520 100644--- a/web/src/features/organizations/server/organizationRouter.ts+++ b/web/src/features/organizations/server/organizationRouter.ts@@ -21,6 +21,12 @@ import { isCloudBillingEnabled } from "@/src/ee/features/billing/utils/isCloudBiimport { shouldAutoEnableV4 } from "@/src/features/events/lib/v4Rollout";import { buildAdminOrgContext } from "@/src/features/organizations/server/adminOrgContext";import { getSfdcService } from "@/src/ee/features/sfdc-sync/server";+import {+ featurePreviewFlags,+ filterFeaturePreviewFlags,+} from "@/src/features/feature-flags/available-flags";+import { setOrganizationFeatureFlagDefault } from "@/src/features/feature-flags/server/organizationFeatureFlags";+import { parseFlags } from "@/src/features/feature-flags/utils";import { env } from "@/src/env.mjs";@@ -54,6 +60,121 @@ export const organizationsRouter = createTRPCRouter({projectIds: organization?.projects.map((project) => project.id) ?? [],});}),+ getFeatureFlagOrgDefaults: protectedOrganizationProcedure+ .input(z.object({ orgId: z.string() }))+ .query(async ({ input, ctx }) => {+ throwIfNoOrganizationAccess({+ session: ctx.session,+ organizationId: input.orgId,+ scope: "organization:update",+ });+ if (+ env.NEXT_PUBLIC_DEMO_ORG_ID &&+ input.orgId === env.NEXT_PUBLIC_DEMO_ORG_ID+ ) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message:+ "Feature preview defaults are unavailable for the demo organization",+ });+ }++ const organization = await ctx.prisma.organization.findUnique({+ where: { id: input.orgId },+ select: {+ featureFlagOrgDefaults: true,+ _count: { select: { organizationMemberships: true } },+ },+ });+ if (!organization) {+ throw new TRPCError({+ code: "NOT_FOUND",+ message: "Organization not found",+ });+ }++ return {+ defaults: filterFeaturePreviewFlags(+ organization.featureFlagOrgDefaults,+ ),+ memberCount: organization._count.organizationMemberships,+ };+ }),+ setFeatureFlagOrgDefault: protectedOrganizationProcedure+ .input(+ z.object({+ orgId: z.string(),+ flag: z.enum(featurePreviewFlags),+ enabled: z.boolean(),+ }),+ )+ .mutation(async ({ input, ctx }) => {+ throwIfNoOrganizationAccess({+ session: ctx.session,+ organizationId: input.orgId,+ scope: "organization:update",+ });+ if (+ env.NEXT_PUBLIC_DEMO_ORG_ID &&+ input.orgId === env.NEXT_PUBLIC_DEMO_ORG_ID+ ) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message:+ "Feature preview defaults are unavailable for the demo organization",+ });+ }++ if (+ input.enabled &&+ env.LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES !== "true"+ ) {+ const actor = await ctx.prisma.user.findUnique({+ where: { id: ctx.session.user.id },+ select: {+ email: true,+ featureFlags: true,+ v4BetaEnabled: true,+ },+ });+ const actorHasPreviewEnabled =+ actor !== null &&+ parseFlags(actor.featureFlags, {+ email: actor.email,+ v4BetaEnabled:+ ctx.session.user.v4BetaEnabled ?? actor.v4BetaEnabled,+ })[input.flag] === true;+ if (!actorHasPreviewEnabled) {+ throw new TRPCError({+ code: "PRECONDITION_FAILED",+ message:+ "Enable and test this preview in your personal Feature Preview settings before enabling it for the organization.",+ });+ }+ }++ const result = await setOrganizationFeatureFlagDefault({+ prisma: ctx.prisma,+ orgId: input.orgId,+ flag: input.flag,+ enabled: input.enabled,+ });++ await auditLog({+ session: ctx.session,+ resourceType: "organization",+ resourceId: input.orgId,+ action: "updateFeatureFlagDefault",+ before: { featureFlagOrgDefaults: result.before },+ after: { featureFlagOrgDefaults: result.after },+ });++ return {+ defaults: result.after,+ flag: input.flag,+ enabled: input.enabled,+ };+ }),create: authenticatedProcedure.input(organizationFormSchema).mutation(async ({ input, ctx }) => {diff --git a/web/src/features/posthog-analytics/usePostHogClientCapture.ts b/web/src/features/posthog-analytics/usePostHogClientCapture.tsindex 25398fd105..d777cee67c 100644--- a/web/src/features/posthog-analytics/usePostHogClientCapture.ts+++ b/web/src/features/posthog-analytics/usePostHogClientCapture.ts@@ -326,6 +326,8 @@ export const events = {"delete_organization","ai_features_toggle","ai_telemetry_toggle",+ "feature_flag_default_toggled",+ "user_feature_flag_toggled",],help_popup: ["opened", "href_clicked"],navigate_detail_pages: ["button_click_prev_or_next"],diff --git a/web/src/features/rbac/components/MembersTable.tsx b/web/src/features/rbac/components/MembersTable.tsxindex 78ca01ce06..397763093b 100644--- a/web/src/features/rbac/components/MembersTable.tsx+++ b/web/src/features/rbac/components/MembersTable.tsx@@ -39,6 +39,11 @@ import { SettingsTableCard } from "@/src/components/layouts/settings-table-card"import useSessionStorage from "@/src/components/useSessionStorage";import { useQueryParam, withDefault, StringParam } from "use-query-params";import { useEffect } from "react";+import { UserFeaturePreviewsControl } from "@/src/features/feature-flags/components/UserFeaturePreviewsPopover";+import type { FeaturePreviewFlag } from "@/src/features/feature-flags/available-flags";+import { env } from "@/src/env.mjs";+import { Button } from "@/src/components/ui/button";+import { Popover, PopoverTrigger } from "@/src/components/ui/popover";export type MembersTableRow = {user: {@@ -50,6 +55,10 @@ export type MembersTableRow = {createdAt: Date;orgRole: Role;projectRole?: Role;+ featurePreviews: Record<FeaturePreviewFlag, boolean> | null;+ featurePreviewManagement:+ | RouterOutput["members"]["allFromOrg"]["memberships"][number]["featurePreviewManagement"]+ | null;meta: {userId: string;orgMembershipId: string;@@ -290,6 +299,45 @@ export function MembersTable({},] satisfies LangfuseColumnDef<MembersTableRow>[]): []),+ ...(!project &&+ hasCudAccessOrgLevel &&+ orgId !== env.NEXT_PUBLIC_DEMO_ORG_ID+ ? ([+ {+ accessorKey: "featurePreviews",+ id: "featurePreviews",+ header: "Feature Previews",+ enableHiding: true,+ cell: ({ row }) => {+ const { featurePreviews, featurePreviewManagement, meta } =+ row.original;+ if (!featurePreviews || !featurePreviewManagement) return null;++ return (+ <Popover>+ <UserFeaturePreviewsControl+ orgId={orgId}+ userId={meta.userId}+ featurePreviews={featurePreviews}+ management={featurePreviewManagement}+ >+ {({ enabledCount, totalCount, content }) => (+ <>+ <PopoverTrigger asChild>+ <Button variant="outline" size="sm">+ {enabledCount}/{totalCount} enabled+ </Button>+ </PopoverTrigger>+ {content}+ </>+ )}+ </UserFeaturePreviewsControl>+ </Popover>+ );+ },+ },+ ] satisfies LangfuseColumnDef<MembersTableRow>[])+ : []),{accessorKey: "createdAt",id: "createdAt",@@ -346,7 +394,9 @@ export function MembersTable({);const convertToTableRow = (- orgMembership: RouterOutput["members"]["allFromOrg"]["memberships"][0], // type of both queries is the same+ orgMembership:+ | RouterOutput["members"]["allFromOrg"]["memberships"][number]+ | RouterOutput["members"]["allFromProject"]["memberships"][number],): MembersTableRow => {return {meta: {@@ -362,6 +412,14 @@ export function MembersTable({createdAt: orgMembership.createdAt,orgRole: orgMembership.role,projectRole: orgMembership.projectRole,+ featurePreviews:+ "featurePreviews" in orgMembership+ ? orgMembership.featurePreviews+ : null,+ featurePreviewManagement:+ "featurePreviewManagement" in orgMembership+ ? orgMembership.featurePreviewManagement+ : null,};};diff --git a/web/src/features/rbac/server/allMembersRoutes.ts b/web/src/features/rbac/server/allMembersRoutes.tsindex 865abbf00c..11bcc862cb 100644--- a/web/src/features/rbac/server/allMembersRoutes.ts+++ b/web/src/features/rbac/server/allMembersRoutes.ts@@ -11,6 +11,12 @@ import { paginationZod, type PrismaClient, Role } from "@langfuse/shared";import { formatAuthProviderName } from "@langfuse/shared/src/server";import { TRPCError } from "@trpc/server";import { z } from "zod";+import { env } from "@/src/env.mjs";+import {+ EMPTY_ORGANIZATION_FEATURE_PREVIEW_STATES,+ getOrganizationFeaturePreviewStatesByUserId,+ getUserFeaturePreviewManagementCapabilities,+} from "@/src/features/feature-flags/server/organizationFeatureFlags";const orgLevelMemberQuery = z.object({orgId: z.string(),@@ -148,7 +154,58 @@ export const allMembersRoutes = {organizationId: input.orgId,scope: "organizationMembers:read",});- return getMembers(ctx.prisma, input);+ const isDemoOrganization = env.NEXT_PUBLIC_DEMO_ORG_ID === input.orgId;+ const canManageFeaturePreviews =+ !isDemoOrganization &&+ hasOrganizationAccess({+ session: ctx.session,+ organizationId: input.orgId,+ scope: "organization:update",+ });+ const [result, organization] = await Promise.all([+ getMembers(ctx.prisma, input),+ canManageFeaturePreviews+ ? ctx.prisma.organization.findUnique({+ where: { id: input.orgId },+ select: { featureFlagOrgDefaults: true },+ })+ : Promise.resolve(null),+ ]);+ const userIds = result.memberships.map((membership) => membership.userId);+ const [featurePreviewsByUserId, managementByUserId] =+ canManageFeaturePreviews+ ? await Promise.all([+ getOrganizationFeaturePreviewStatesByUserId({+ prisma: ctx.prisma,+ userIds,+ organizationDefaults:+ organization?.featureFlagOrgDefaults ?? [],+ }),+ getUserFeaturePreviewManagementCapabilities({+ prisma: ctx.prisma,+ actorUserId: ctx.session.user.id,+ actorIsPlatformAdmin: ctx.session.user.admin === true,+ targetUserIds: userIds,+ demoOrgId: env.NEXT_PUBLIC_DEMO_ORG_ID,+ }),+ ])+ : [new Map(), new Map()];++ return {+ ...result,+ memberships: result.memberships.map((membership) => ({+ ...membership,+ featurePreviews: canManageFeaturePreviews+ ? (featurePreviewsByUserId.get(membership.userId) ??+ EMPTY_ORGANIZATION_FEATURE_PREVIEW_STATES)+ : null,+ featurePreviewManagement: canManageFeaturePreviews+ ? (managementByUserId.get(membership.userId) ?? {+ allowed: false,+ })+ : null,+ })),+ };}),allFromProject: protectedProjectProcedure.input(projectLevelMemberQuery)diff --git a/web/src/features/rbac/server/membersRouter.ts b/web/src/features/rbac/server/membersRouter.tsindex 04c9c235c2..0723ec9859 100644--- a/web/src/features/rbac/server/membersRouter.ts+++ b/web/src/features/rbac/server/membersRouter.ts@@ -33,6 +33,8 @@ import {import { allMembersRoutes } from "@/src/features/rbac/server/allMembersRoutes";import { allInvitesRoutes } from "@/src/features/rbac/server/allInvitesRoutes";import { orderedRoles } from "@/src/features/rbac/constants/orderedRoles";+import { featurePreviewFlags } from "@/src/features/feature-flags/available-flags";+import { setUserFeaturePreviewWithAuthorization } from "@/src/features/feature-flags/server/organizationFeatureFlags";function buildUserSearchFilter(searchQuery: string | undefined | null) {if (searchQuery === undefined || searchQuery === null || searchQuery === "") {@@ -629,6 +631,73 @@ export const membersRouter = createTRPCRouter({return updatedMembership;}),+ setUserFeaturePreviewEnabled: protectedOrganizationProcedure+ .input(+ z.object({+ orgId: z.string(),+ userId: z.string(),+ flag: z.enum(featurePreviewFlags),+ enabled: z.boolean(),+ }),+ )+ .mutation(async ({ input, ctx }) => {+ throwIfNoOrganizationAccess({+ session: ctx.session,+ organizationId: input.orgId,+ scope: "organization:update",+ });+ if (+ env.NEXT_PUBLIC_DEMO_ORG_ID &&+ input.orgId === env.NEXT_PUBLIC_DEMO_ORG_ID+ ) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message:+ "Feature previews cannot be managed in the demo organization",+ });+ }++ const result = await setUserFeaturePreviewWithAuthorization({+ prisma: ctx.prisma,+ actorUserId: ctx.session.user.id,+ actorIsPlatformAdmin: ctx.session.user.admin === true,+ currentOrgId: input.orgId,+ targetUserId: input.userId,+ flag: input.flag,+ enabled: input.enabled,+ demoOrgId: env.NEXT_PUBLIC_DEMO_ORG_ID,+ });+ if (!result) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message:+ "You can only change this user's feature flags if you are an administrator in every organization they belong to.",+ });+ }++ await auditLog({+ session: ctx.session,+ resourceType: "orgMembership",+ resourceId: result.membershipId,+ action: "updateUserFeatureFlag",+ before: {+ flag: input.flag,+ override: result.before,+ scope: "global",+ },+ after: {+ flag: input.flag,+ override: result.after,+ scope: "global",+ },+ });++ return {+ userId: input.userId,+ flag: input.flag,+ enabled: input.enabled,+ };+ }),updateProjectRole: protectedOrganizationProcedure.input(z.object({diff --git a/web/src/features/search-bar/README.md b/web/src/features/search-bar/README.mdindex b30197f62b..b7ac466e96 100644--- a/web/src/features/search-bar/README.md+++ b/web/src/features/search-bar/README.md@@ -20,16 +20,8 @@ tables (no opt-in). Based on the `langfuse-search-bar` prototype.The **v4 beta** gate is implicit: `EventsTable` only mounts on the v4Observations/Traces tables, so call sites still read as`isBetaEnabled && useSearchBarEnabled()`.-- **Rollout/rollback (temporary).** GA was shipped by force-on shim, not by- deleting the opt-in: `useSearchBarEnabled` hard-returns `true` and the- "Filter Search Bar" tile was removed from the Feature Preview modal, but the- `searchBar` flag plumbing is intentionally **left as dead code** for a day or- two so a rollback is a one-line revert. The pieces still present and marked- `TODO(remove ~2026-06-19)`: the `searchBar` entry in- `features/feature-flags/available-flags.ts`, the- `userAccount.setFeaturePreviewEnabled` allowlist, and the modal's- `PreviewFlag`/registry entry (`features/feature-previews/`). Once the rollout- is confirmed stable, delete those and inline `true` at the call site.+- The search bar is not a Feature Preview and has no user or organization+ toggle.## Query languagediff --git a/web/src/features/search-bar/hooks/useSearchBarEnabled.ts b/web/src/features/search-bar/hooks/useSearchBarEnabled.tsindex 05f8f6dae6..70d9a36aef 100644--- a/web/src/features/search-bar/hooks/useSearchBarEnabled.ts+++ b/web/src/features/search-bar/hooks/useSearchBarEnabled.ts@@ -4,22 +4,7 @@* Preview opt-in. The bar still only renders on the v4 Observations/Traces* tables, so call sites keep gating on `isBetaEnabled && useSearchBarEnabled()`* (EventsTable only mounts in v4 mode, so the v4 gate is implicit there).- *- * TODO(remove ~2026-06-19, after the GA rollout has been stable for a day or- * two): this hook is now a force-on shim kept only so a rollback to the opt-in- * is a one-line revert (restore the `useSession` read below). Once we're- * confident, delete this hook and inline `true` at the call site, and remove- * the dead `searchBar` Feature Preview plumbing:- * - `features/feature-flags/available-flags.ts` ("searchBar")- * - `server/api/routers/userAccount.ts` (setFeaturePreviewEnabled allowlist)- * - `features/feature-previews/components/FeaturePreviewModal.tsx` (registry- * entry + `PreviewFlag` type + filter-search-bar illustration assets)- * - the `searchBar` rows in `userAccount.servertest.ts` /- * `FeaturePreviewModal.stories.tsx`*/export function useSearchBarEnabled(): boolean {return true;- // Rollback to the per-user Feature Preview opt-in by restoring:- // return useSession().data?.user?.featureFlags.searchBar === true;- // (re-add `import { useSession } from "next-auth/react";` above).}diff --git a/web/src/features/traces/components/TracePanelNavigation.tsx b/web/src/features/traces/components/TracePanelNavigation.tsxindex b8a13a17d0..7ad3bc13cd 100644--- a/web/src/features/traces/components/TracePanelNavigation.tsx+++ b/web/src/features/traces/components/TracePanelNavigation.tsx@@ -25,9 +25,11 @@ import { TraceTimeline } from "./TraceTimeline/TraceTimeline";import { TraceTimelineCompact } from "./TraceTimelineDense/TraceTimelineCompact";import { useMemo } from "react";import useIsFeatureEnabled from "@/src/features/feature-flags/hooks/useIsFeatureEnabled";+import { useTraceData } from "@/src/features/traces/contexts/TraceDataContext";export function TracePanelNavigation() {const { searchQuery } = useSearch();+ const { trace } = useTraceData();const [viewMode] = useQueryParam("view", StringParam);// The Compact Timeline feature preview changes what the Timeline view IS,@@ -37,6 +39,7 @@ export function TracePanelNavigation() {// it silently — the preview toggle is the way in.const isCompactTimelineEnabled = useIsFeatureEnabled("compactTimeline", {enableForAdmins: false,+ projectId: trace.projectId,});const hasQuery = searchQuery.trim().length > 0;const isTimelineView = viewMode === "timeline";diff --git a/web/src/pages/organization/[organizationId]/settings/index.tsx b/web/src/pages/organization/[organizationId]/settings/index.tsxindex 1c9d492e6d..33a0014c37 100644--- a/web/src/pages/organization/[organizationId]/settings/index.tsx+++ b/web/src/pages/organization/[organizationId]/settings/index.tsx@@ -21,6 +21,7 @@ import { env } from "@/src/env.mjs";import { OrgAuditLogsSettingsPage } from "@/src/ee/features/audit-log-viewer/OrgAuditLogsSettingsPage";import { useHasOrganizationAccess } from "@/src/features/rbac/utils/checkOrganizationAccess";import { useV4UpgradeUiFlag } from "@/src/features/v4-migration/useV4UpgradeUiEnabled";+import { OrganizationFeaturePreviewsSettings } from "@/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings";type OrganizationSettingsPage = {title: string;@@ -39,6 +40,10 @@ export function useOrganizationSettingsPages(): OrganizationSettingsPage[] {});const showOrgApiKeySettings = hasAdminApiEntitlement && hasOrgApiKeyAccess;const showAuditLogs = useHasEntitlement("audit-logs");+ const canUpdateOrganization = useHasOrganizationAccess({+ organizationId: organization?.id,+ scope: "organization:update",+ });const plan = usePlan();const isLangfuseCloud = isCloudPlan(plan) ?? false;const isCloudBillingAvailable = useIsCloudBillingAvailable();@@ -53,6 +58,8 @@ export function useOrganizationSettingsPages(): OrganizationSettingsPage[] {showAuditLogs,isLangfuseCloud,showV4Migration,+ showFeaturePreviews:+ canUpdateOrganization && organization.id !== env.NEXT_PUBLIC_DEMO_ORG_ID,});}@@ -63,6 +70,7 @@ export const getOrganizationSettingsPages = ({showAuditLogs,isLangfuseCloud,showV4Migration,+ showFeaturePreviews,}: {organization: { id: string; name: string; metadata: Record<string, unknown> };showBillingSettings: boolean;@@ -70,6 +78,7 @@ export const getOrganizationSettingsPages = ({showAuditLogs: boolean;isLangfuseCloud: boolean;showV4Migration: boolean;+ showFeaturePreviews: boolean;}): OrganizationSettingsPage[] => [{title: "General",@@ -106,6 +115,13 @@ export const getOrganizationSettingsPages = ({</div>),},+ {+ title: "Feature Previews",+ slug: "feature-previews",+ cmdKKeywords: ["feature", "preview", "flags", "beta"],+ content: <OrganizationFeaturePreviewsSettings orgId={organization.id} />,+ show: showFeaturePreviews,+ },{title: "API Keys",slug: "api-keys",diff --git a/web/src/server/api/routers/userAccount.ts b/web/src/server/api/routers/userAccount.tsindex 442328c0f9..1cdc208024 100644--- a/web/src/server/api/routers/userAccount.ts+++ b/web/src/server/api/routers/userAccount.ts@@ -10,11 +10,8 @@ import { canToggleV4 } from "@/src/features/events/lib/v4Rollout";import { V4_PREVIEW_LABEL } from "@/src/features/events/lib/v4PreviewLabel";import { env } from "@/src/env.mjs";import { getSfdcService } from "@/src/ee/features/sfdc-sync/server";-import {- getFeaturePreviewOptOutFlag,- receivesFeaturePreviewsByDefault,-} from "@/src/features/feature-flags/utils";import { featurePreviewFlags } from "@/src/features/feature-flags/available-flags";+import { setUserFeaturePreview } from "@/src/features/feature-flags/server/organizationFeatureFlags";const updateDisplayNameSchema = z.object({name: StringNoHTML.min(1, "Name cannot be empty").max(@@ -124,38 +121,14 @@ export const userAccountRouter = createTRPCRouter({});}- // Serializable transaction: the read-modify-write of the featureFlags- // array is not atomic on its own, so two parallel toggles of DIFFERENT- // flags from one tab (the modal only disables the in-flight row) would- // last-write-wins and silently drop one. Mirrors the `delete` mutation.- await ctx.prisma.$transaction(- async (tx) => {- const currentUser = await tx.user.findUnique({- where: { id: userId },- select: { featureFlags: true, email: true },- });- if (!currentUser) {- throw new TRPCError({- code: "NOT_FOUND",- message: "User not found",- });- }- const optOutFlag = getFeaturePreviewOptOutFlag(input.flag);- const featureFlagsWithoutOverride = currentUser.featureFlags.filter(- (flag) => flag !== input.flag && flag !== optOutFlag,- );- const nextFeatureFlags = input.enabled- ? [...featureFlagsWithoutOverride, input.flag]- : receivesFeaturePreviewsByDefault(currentUser.email)- ? [...featureFlagsWithoutOverride, optOutFlag]- : featureFlagsWithoutOverride;- await tx.user.update({- where: { id: userId },- data: { featureFlags: { set: nextFeatureFlags } },- });- },- { isolationLevel: Prisma.TransactionIsolationLevel.Serializable },- );+ // The helper serializes and retries the read-modify-write so parallel+ // toggles of different flags cannot silently drop one another.+ await setUserFeaturePreview({+ prisma: ctx.prisma,+ userId,+ flag: input.flag,+ enabled: input.enabled,+ });return {success: true,diff --git a/web/src/server/auth.ts b/web/src/server/auth.tsindex 93c3e2cdd2..c4a65f8bfd 100644--- a/web/src/server/auth.ts+++ b/web/src/server/auth.ts@@ -11,7 +11,10 @@ import {hashPassword,verifyPassword,} from "@/src/features/auth-credentials/lib/credentialsServerUtils";-import { parseFlags } from "@/src/features/feature-flags/utils";+import {+ parseFlags,+ parseFlagsWithOrganizationDefaults,+} from "@/src/features/feature-flags/utils";import { env } from "@/src/env.mjs";import { createProjectMembershipsOnSignup } from "@/src/features/auth/lib/createProjectMembershipsOnSignup";import { type AdClickIds } from "@/src/features/auth/lib/signupAttribution";@@ -957,6 +960,14 @@ export async function getAuthOptions(signupAttribution?: {orgMembership.organization.aiFeaturesEnabled,aiTelemetryEnabled:orgMembership.organization.aiTelemetryEnabled,+ featureFlags: parseFlagsWithOrganizationDefaults(+ dbUser.featureFlags,+ orgMembership.organization.featureFlagOrgDefaults,+ {+ email: dbUser.email,+ v4BetaEnabled,+ },+ ),cloudConfig: parsedCloudConfig.data,projects: orgMembership.organization.projects.map((project) => {diff --git a/web/types/next-auth.d.ts b/web/types/next-auth.d.tsindex bdb0310791..507de7eed5 100644--- a/web/types/next-auth.d.ts+++ b/web/types/next-auth.d.ts@@ -43,6 +43,7 @@ declare module "next-auth" {metadata: Record<string, unknown>;aiFeaturesEnabled: boolean;aiTelemetryEnabled: boolean;+ featureFlags?: Flags;projects: {id: PrismaProject["id"];name: PrismaProject["name"];