Skip to content

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

🚏 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.ts
index 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.ts
index 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.ts
index 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;
}