Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

fix(frontend): forward sentry-trace and baggage across API proxy (#12835)

Nicholas Tindle59273fe6a09a
diff --git a/autogpt_platform/frontend/src/app/api/mutators/__tests__/custom-mutator.test.ts b/autogpt_platform/frontend/src/app/api/mutators/__tests__/custom-mutator.test.ts
index 7debeb3f5a..89b17866c3 100644
--- a/autogpt_platform/frontend/src/app/api/mutators/__tests__/custom-mutator.test.ts
+++ b/autogpt_platform/frontend/src/app/api/mutators/__tests__/custom-mutator.test.ts
@@ -26,13 +26,19 @@ vi.mock("@/lib/autogpt-server-api/helpers", () => ({
getServerAuthToken: vi.fn(),
}));
+vi.mock("@sentry/nextjs", () => ({
+ getTraceData: vi.fn(() => ({})),
+}));
+
import { customMutator } from "../custom-mutator";
import { getSystemHeaders } from "@/lib/impersonation";
import { environment } from "@/services/environment";
import { IMPERSONATION_HEADER_NAME } from "@/lib/constants";
+import * as Sentry from "@sentry/nextjs";
const mockIsClientSide = vi.mocked(environment.isClientSide);
const mockGetSystemHeaders = vi.mocked(getSystemHeaders);
+const mockGetTraceData = vi.mocked(Sentry.getTraceData);
describe("customMutator — impersonation header", () => {
beforeEach(() => {
@@ -88,3 +94,92 @@ describe("customMutator — impersonation header", () => {
expect(headers["X-Custom-Header"]).toBe("custom-value");
});
});
+
+describe("customMutator — Sentry trace propagation", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockIsClientSide.mockReturnValue(true);
+ mockGetSystemHeaders.mockReturnValue({});
+ mockGetTraceData.mockReturnValue({});
+ vi.stubGlobal(
+ "fetch",
+ vi.fn().mockResolvedValue({
+ ok: true,
+ status: 200,
+ headers: new Headers({ "content-type": "application/json" }),
+ json: () => Promise.resolve({}),
+ }),
+ );
+ });
+
+ it("attaches sentry-trace and baggage headers from Sentry trace data on client-side", async () => {
+ mockGetTraceData.mockReturnValue({
+ "sentry-trace": "0123456789abcdef0123456789abcdef-0123456789abcdef-1",
+ baggage: "sentry-environment=local,sentry-public_key=abc",
+ });
+
+ await customMutator("/test", { method: "GET" });
+
+ const fetchCall = vi.mocked(fetch).mock.calls[0];
+ const headers = fetchCall[1]?.headers as Record<string, string>;
+ expect(headers["sentry-trace"]).toBe(
+ "0123456789abcdef0123456789abcdef-0123456789abcdef-1",
+ );
+ expect(headers["baggage"]).toBe(
+ "sentry-environment=local,sentry-public_key=abc",
+ );
+ });
+
+ it("omits sentry-trace headers when Sentry has no active trace", async () => {
+ mockGetTraceData.mockReturnValue({});
+
+ await customMutator("/test", { method: "GET" });
+
+ const fetchCall = vi.mocked(fetch).mock.calls[0];
+ const headers = fetchCall[1]?.headers as Record<string, string>;
+ expect(headers["sentry-trace"]).toBeUndefined();
+ expect(headers["baggage"]).toBeUndefined();
+ });
+
+ it("does not attach Sentry trace headers on server-side", async () => {
+ mockIsClientSide.mockReturnValue(false);
+ mockGetTraceData.mockReturnValue({
+ "sentry-trace": "should-not-appear",
+ });
+
+ await customMutator("/test", { method: "GET" });
+
+ expect(mockGetTraceData).not.toHaveBeenCalled();
+ });
+
+ it("skips non-string values returned by Sentry.getTraceData", async () => {
+ // Simulate a non-string slipping into the trace-data object
+ mockGetTraceData.mockReturnValue({
+ "sentry-trace": "real-trace",
+ "sentry-sampled": 1,
+ } as unknown as ReturnType<typeof Sentry.getTraceData>);
+
+ await customMutator("/test", { method: "GET" });
+
+ const fetchCall = vi.mocked(fetch).mock.calls[0];
+ const headers = fetchCall[1]?.headers as Record<string, string>;
+ expect(headers["sentry-trace"]).toBe("real-trace");
+ expect(headers["sentry-sampled"]).toBeUndefined();
+ });
+
+ it("falls back to an empty object when Sentry.getTraceData is undefined", async () => {
+ // Simulate an older @sentry/nextjs build where getTraceData isn't exported
+ (Sentry as { getTraceData?: unknown }).getTraceData =
+ undefined as unknown as typeof Sentry.getTraceData;
+
+ await customMutator("/test", { method: "GET" });
+
+ const fetchCall = vi.mocked(fetch).mock.calls[0];
+ const headers = fetchCall[1]?.headers as Record<string, string>;
+ expect(headers["sentry-trace"]).toBeUndefined();
+ expect(headers["baggage"]).toBeUndefined();
+
+ // Restore for subsequent tests
+ (Sentry as { getTraceData?: unknown }).getTraceData = mockGetTraceData;
+ });
+});
diff --git a/autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts b/autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts
index 05b49f10e7..019e911fbf 100644
--- a/autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts
+++ b/autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts
@@ -3,6 +3,7 @@ import {
createRequestHeaders,
getServerAuthToken,
} from "@/lib/autogpt-server-api/helpers";
+import * as Sentry from "@sentry/nextjs";
import { getSystemHeaders } from "@/lib/impersonation";
import { environment } from "@/services/environment";
@@ -53,6 +54,12 @@ export const customMutator = async <
};
if (environment.isClientSide()) {
+ const traceData = Sentry.getTraceData?.() ?? {};
+ for (const [key, value] of Object.entries(traceData)) {
+ if (typeof value === "string") {
+ headers[key] = value;
+ }
+ }
Object.assign(headers, getSystemHeaders());
}
diff --git a/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.test.ts b/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.test.ts
new file mode 100644
index 0000000000..690a6141a5
--- /dev/null
+++ b/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.test.ts
@@ -0,0 +1,171 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/supabase/server/getServerSupabase", () => ({
+ getServerSupabase: vi.fn(),
+}));
+
+vi.mock("@/services/environment", () => ({
+ environment: {
+ isServerSide: vi.fn(() => true),
+ isClientSide: vi.fn(() => false),
+ getAGPTServerApiUrl: vi.fn(() => "http://localhost:8006/api"),
+ },
+}));
+
+import { createRequestHeaders } from "./helpers";
+import {
+ API_KEY_HEADER_NAME,
+ IMPERSONATION_HEADER_NAME,
+} from "@/lib/constants";
+
+function makeRequest(headers: Record<string, string>): Request {
+ return new Request("http://example.com/test", { headers });
+}
+
+describe("createRequestHeaders — basics", () => {
+ it("adds Content-Type when hasRequestBody is true", () => {
+ const headers = createRequestHeaders("token-abc", true);
+ expect(headers["Content-Type"]).toBe("application/json");
+ });
+
+ it("omits Content-Type when hasRequestBody is false", () => {
+ const headers = createRequestHeaders("token-abc", false);
+ expect(headers["Content-Type"]).toBeUndefined();
+ });
+
+ it("uses the provided contentType override", () => {
+ const headers = createRequestHeaders(
+ "token-abc",
+ true,
+ "application/x-www-form-urlencoded",
+ );
+ expect(headers["Content-Type"]).toBe("application/x-www-form-urlencoded");
+ });
+
+ it("adds Authorization header when token is a real value", () => {
+ const headers = createRequestHeaders("token-abc", false);
+ expect(headers["Authorization"]).toBe("Bearer token-abc");
+ });
+
+ it("omits Authorization when token is the 'no-token-found' sentinel", () => {
+ const headers = createRequestHeaders("no-token-found", false);
+ expect(headers["Authorization"]).toBeUndefined();
+ });
+
+ it("omits Authorization when token is empty", () => {
+ const headers = createRequestHeaders("", false);
+ expect(headers["Authorization"]).toBeUndefined();
+ });
+});
+
+describe("createRequestHeaders — Sentry trace forwarding", () => {
+ it("forwards sentry-trace and baggage headers when present on originalRequest", () => {
+ const request = makeRequest({
+ "sentry-trace": "0123456789abcdef0123456789abcdef-0123456789abcdef-1",
+ baggage: "sentry-environment=local,sentry-public_key=abc",
+ });
+
+ const headers = createRequestHeaders(
+ "token-abc",
+ false,
+ undefined,
+ request,
+ );
+
+ expect(headers["sentry-trace"]).toBe(
+ "0123456789abcdef0123456789abcdef-0123456789abcdef-1",
+ );
+ expect(headers["baggage"]).toBe(
+ "sentry-environment=local,sentry-public_key=abc",
+ );
+ });
+
+ it("forwards only sentry-trace when baggage is absent", () => {
+ const request = makeRequest({
+ "sentry-trace": "trace-id-only",
+ });
+
+ const headers = createRequestHeaders(
+ "token-abc",
+ false,
+ undefined,
+ request,
+ );
+
+ expect(headers["sentry-trace"]).toBe("trace-id-only");
+ expect(headers["baggage"]).toBeUndefined();
+ });
+
+ it("forwards only baggage when sentry-trace is absent", () => {
+ const request = makeRequest({
+ baggage: "sentry-environment=prod",
+ });
+
+ const headers = createRequestHeaders(
+ "token-abc",
+ false,
+ undefined,
+ request,
+ );
+
+ expect(headers["sentry-trace"]).toBeUndefined();
+ expect(headers["baggage"]).toBe("sentry-environment=prod");
+ });
+
+ it("does not forward sentry headers when originalRequest has none", () => {
+ const request = makeRequest({ "X-Other-Header": "something" });
+
+ const headers = createRequestHeaders(
+ "token-abc",
+ false,
+ undefined,
+ request,
+ );
+
+ expect(headers["sentry-trace"]).toBeUndefined();
+ expect(headers["baggage"]).toBeUndefined();
+ });
+
+ it("does not attempt to forward sentry headers when originalRequest is omitted", () => {
+ const headers = createRequestHeaders("token-abc", false);
+
+ expect(headers["sentry-trace"]).toBeUndefined();
+ expect(headers["baggage"]).toBeUndefined();
+ });
+});
+
+describe("createRequestHeaders — impersonation and API-key forwarding", () => {
+ it("forwards the impersonation header alongside sentry headers", () => {
+ const request = makeRequest({
+ [IMPERSONATION_HEADER_NAME]: "impersonated-user-xyz",
+ "sentry-trace": "trace-id",
+ });
+
+ const headers = createRequestHeaders(
+ "token-abc",
+ false,
+ undefined,
+ request,
+ );
+
+ expect(headers[IMPERSONATION_HEADER_NAME]).toBe("impersonated-user-xyz");
+ expect(headers["sentry-trace"]).toBe("trace-id");
+ });
+
+ it("forwards the API key header alongside sentry headers", () => {
+ const request = makeRequest({
+ [API_KEY_HEADER_NAME]: "api-key-value",
+ baggage: "sentry-environment=local",
+ });
+
+ const headers = createRequestHeaders(
+ "token-abc",
+ false,
+ undefined,
+ request,
+ );
+
+ expect(headers[API_KEY_HEADER_NAME]).toBe("api-key-value");
+ expect(headers["baggage"]).toBe("sentry-environment=local");
+ });
+});
diff --git a/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.ts b/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.ts
index 4cb24df77d..7e6bc0f458 100644
--- a/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.ts
+++ b/autogpt_platform/frontend/src/lib/autogpt-server-api/helpers.ts
@@ -163,6 +163,15 @@ export function createRequestHeaders(
if (apiKeyHeader) {
headers[API_KEY_HEADER_NAME] = apiKeyHeader;
}
+
+ // Forward Sentry distributed-tracing headers so the backend transaction
+ // continues the browser span instead of starting a disconnected trace.
+ for (const name of ["sentry-trace", "baggage"] as const) {
+ const value = originalRequest.headers.get(name);
+ if (value) {
+ headers[name] = value;
+ }
+ }
}
return headers;