Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🚏 feat: Central Trace Destination Opt-Out for Langfuse (#14838)
Danny Avilacd4511038da6
diff --git a/packages/api/src/langfuse/destinations.ts b/packages/api/src/langfuse/destinations.tsindex 10dc1adf2d..ac5f6a7d36 100644--- a/packages/api/src/langfuse/destinations.ts+++ b/packages/api/src/langfuse/destinations.ts@@ -30,6 +30,16 @@ export type LangfuseScoreDestination = {authorization: string;};+export type LangfuseScoreDestinationOptions = {+ waitForCentralProjectId?: boolean;+ /**+ * Deployments that route traces per tenant may want a turn's spans to reach+ * only the tenant destination. Setting this false drops the central project+ * from resolution without disturbing tenant or connection destinations.+ */+ centralTraceExportEnabled?: boolean;+};+export function getLangfuseDestinationId(baseUrl: string, projectId: string): string {return createHash('sha256').update(`${baseUrl.replace(/\/+$/, '')}\n${projectId}`)@@ -204,7 +214,10 @@ export async function getScoreDestinations(appConfig: AppConfig | undefined,traceId: string,sampled?: boolean,- options?: { waitForCentralProjectId?: boolean },+ {+ waitForCentralProjectId = true,+ centralTraceExportEnabled = true,+ }: LangfuseScoreDestinationOptions = {},): Promise<LangfuseScoreDestination[]> {if (!isLangfuseTracingEnabled() ||@@ -215,8 +228,15 @@ export async function getScoreDestinations(}if (!usesLangfuseMultiTenantRouting()) {+ /** Mirrors `resolveLangfuseExportPlan`: without fanout there is no tenant+ * route to fall back on, so suppressing central export disables the trace+ * outright. Capturing a destination here would let later feedback reach a+ * project the trace never went to. */+ if (!centralTraceExportEnabled) {+ return [];+ }return hasLangfuseEnvCredentials()- ? [await getCentralScoreDestination(options?.waitForCentralProjectId !== false)].filter(+ ? [await getCentralScoreDestination(waitForCentralProjectId)].filter((destination): destination is LangfuseScoreDestination => Boolean(destination),): [getConfiguredScoreDestination(appConfig)].filter(@@ -225,7 +245,9 @@ export async function getScoreDestinations(}const destinations = [- await getCentralScoreDestination(options?.waitForCentralProjectId !== false),+ centralTraceExportEnabled+ ? await getCentralScoreDestination(waitForCentralProjectId)+ : undefined,getTenantScoreDestination(appConfig),].filter((destination): destination is LangfuseScoreDestination => Boolean(destination));const unique = new Map<string, LangfuseScoreDestination>();@@ -251,11 +273,21 @@ export async function getLangfuseTraceDestinationIds(appConfig: AppConfig | undefined,traceId: string,sampled?: boolean,+ {+ centralTraceExportEnabled = true,+ }: Pick<LangfuseScoreDestinationOptions, 'centralTraceExportEnabled'> = {},): Promise<string[] | undefined> {const destinations = await getScoreDestinations(appConfig, traceId, sampled, {waitForCentralProjectId: false,+ centralTraceExportEnabled,});if (destinations.some(({ id }) => id == null)) {+ /** A tenant destination's `projectId` is optional, so an eligible project can+ * have no stable id to record. `undefined` defers to whatever policy the+ * feedback path resolves — an empty list would instead reject every+ * destination, silently dropping feedback the tenant should receive.+ * `sendFeedbackScore` must be given the same `centralTraceExportEnabled`+ * for that deferral to honor a central opt-out. */return undefined;}return destinations.map(({ id }) => id as string);@@ -264,6 +296,9 @@ export async function getLangfuseTraceDestinationIds(export async function getLangfuseTraceMessageFields(appConfig: AppConfig | undefined,messageId: string,+ {+ centralTraceExportEnabled = true,+ }: Pick<LangfuseScoreDestinationOptions, 'centralTraceExportEnabled'> = {},): Promise<{ langfuseSampled: boolean; langfuseDestinationIds?: string[] }> {const traceId = traceIdForMessage(messageId);const langfuseSampled = isLangfuseTraceSampled(traceId);@@ -273,6 +308,7 @@ export async function getLangfuseTraceMessageFields(appConfig,traceId,langfuseSampled,+ { centralTraceExportEnabled },),};}diff --git a/packages/api/src/langfuse/feedback.spec.ts b/packages/api/src/langfuse/feedback.spec.tsindex e114cbc967..9c4be391b1 100644--- a/packages/api/src/langfuse/feedback.spec.ts+++ b/packages/api/src/langfuse/feedback.spec.ts@@ -1203,4 +1203,85 @@ describe('Langfuse feedback scores', () => {expect(getFetchMock()).not.toHaveBeenCalled();});+ it('captures no destinations when central export is suppressed without a fanout route', async () => {+ delete process.env.LANGFUSE_PUBLIC_KEY;+ delete process.env.LANGFUSE_SECRET_KEY;+ process.env.LANGFUSE_FANOUT_TENANT_DESTINATIONS = 'eu=http://tenant-langfuse:3000';+ await loadFeedback();+ const { getLangfuseTraceDestinationIds } = await import('./destinations');++ /** `resolveLangfuseExportPlan` reports `disabled` for this shape — no fanout+ * route to fall back on — so capturing the configured connection would let+ * later feedback reach a project the trace never went to. */+ await expect(+ getLangfuseTraceDestinationIds(+ appConfigWithLangfuse({+ publicKey: 'tenant-public-key',+ secretKey: encryptedTenantSecret(),+ destination: 'eu',+ }),+ 'trace-id',+ true,+ { centralTraceExportEnabled: false },+ ),+ ).resolves.toEqual([]);+ });++ it('records no restriction when a suppressed-central trace has no identifiable destination', async () => {+ enableTenantFanout();+ process.env.LANGFUSE_FANOUT_TENANT_DESTINATIONS = 'eu=http://tenant-langfuse:3000';+ await loadFeedback();+ const { getLangfuseTraceDestinationIds } = await import('./destinations');++ /** Tenant `projectId` is optional, so this eligible destination carries no+ * stable id. An empty list would reject it at feedback time and drop the+ * rating; the opt-out is re-asserted through `sendFeedbackScore` instead. */+ await expect(+ getLangfuseTraceDestinationIds(+ appConfigWithLangfuse({+ publicKey: 'tenant-public-key',+ secretKey: encryptedTenantSecret(),+ destination: 'eu',+ projectId: undefined,+ }),+ 'trace-id',+ true,+ { centralTraceExportEnabled: false },+ ),+ ).resolves.toBeUndefined();+ });++ it('sends unrestricted suppressed-central feedback to the tenant only', async () => {+ enableTenantFanout();+ process.env.LANGFUSE_BASE_URL = 'http://central-langfuse:3000';+ process.env.LANGFUSE_FANOUT_TENANT_DESTINATIONS = 'eu=http://tenant-langfuse:3000';+ const { sendFeedbackScore } = await loadFeedback();++ /** The trace reached the tenant through its fanout route while central export+ * was suppressed, and left no destination ids to filter on. The rating has to+ * follow the same policy: tenant receives it, central stays excluded. */+ await sendFeedbackScore({+ traceId: 'trace-id',+ feedback: { rating: 'thumbsUp' },+ destinationIds: undefined,+ centralTraceExportEnabled: false,+ appConfig: appConfigWithLangfuse({+ publicKey: 'tenant-public-key',+ secretKey: encryptedTenantSecret(),+ destination: 'eu',+ projectId: undefined,+ }),+ });++ expect(getFetchMock()).toHaveBeenCalledTimes(1);+ expect(getFetchMock()).toHaveBeenCalledWith(+ 'http://tenant-langfuse:3000/api/public/scores',+ expect.objectContaining({+ method: 'POST',+ headers: expect.objectContaining({+ Authorization: getTenantAuthorization(),+ }),+ }),+ );+ });});diff --git a/packages/api/src/langfuse/feedback.ts b/packages/api/src/langfuse/feedback.tsindex 6fffa64da4..ca34ac0750 100644--- a/packages/api/src/langfuse/feedback.ts+++ b/packages/api/src/langfuse/feedback.ts@@ -18,6 +18,13 @@ export type SendFeedbackScoreParams = {metadata?: LangfuseFeedbackMetadata;observationId?: string;appConfig?: AppConfig;+ /**+ * Must mirror the value used when the trace was generated. `destinationIds`+ * only restricts feedback to destinations that carry a stable id, so a caller+ * that opts out of central export has to re-assert it here for destinations+ * whose project identity is unknown.+ */+ centralTraceExportEnabled?: boolean;};const ENVIRONMENT = process.env.LANGFUSE_TRACING_ENVIRONMENT;@@ -110,15 +117,16 @@ export async function sendFeedbackScore({metadata = {},observationId,appConfig,+ centralTraceExportEnabled,}: SendFeedbackScoreParams): Promise<void> {if (!traceId) {return;}const destinationIdSet = destinationIds == null ? undefined : new Set(destinationIds);- const destinations = (await getScoreDestinations(appConfig, traceId, sampled)).filter(- ({ id }) => destinationIdSet == null || (id != null && destinationIdSet.has(id)),- );+ const destinations = (+ await getScoreDestinations(appConfig, traceId, sampled, { centralTraceExportEnabled })+ ).filter(({ id }) => destinationIdSet == null || (id != null && destinationIdSet.has(id)));if (destinations.length === 0) {return;}