From a068848c9866ace174eab0ccf7df4b1ecac61fec Mon Sep 17 00:00:00 2001
From: Onur Temizkan <onur@narval.co.uk>
Date: Fri, 20 Feb 2026 13:23:58 +0000
Subject: [PATCH 1/6] feat(remix): Add Server-Timing header trace propagation

---
 .../remix-hydrogen/app/entry.server.tsx       |  10 +-
 .../tests/server-timing-header.test.ts        |  17 +++
 .../remix-server-timing/.eslintrc.js          |   4 +
 .../remix-server-timing/.gitignore            |   3 +
 .../remix-server-timing/.npmrc                |   2 +
 .../remix-server-timing/app/entry.client.tsx  |  44 ++++++
 .../remix-server-timing/app/entry.server.tsx  | 115 +++++++++++++++
 .../remix-server-timing/app/root.tsx          |  63 +++++++++
 .../remix-server-timing/app/routes/_index.tsx |  28 ++++
 .../app/routes/redirect-test.tsx              |   5 +
 .../app/routes/user.$id.tsx                   |  19 +++
 .../remix-server-timing/globals.d.ts          |   2 +
 .../remix-server-timing/instrument.server.cjs |   8 ++
 .../remix-server-timing/package.json          |  42 ++++++
 .../remix-server-timing/playwright.config.mjs |   8 ++
 .../remix-server-timing/remix.env.d.ts        |   2 +
 .../remix-server-timing/start-event-proxy.mjs |   6 +
 .../server-timing-trace-propagation.test.ts   |  73 ++++++++++
 .../remix-server-timing/tsconfig.json         |  23 +++
 .../remix-server-timing/vite.config.ts        |  15 ++
 packages/remix/src/cloudflare/index.ts        |   1 +
 packages/remix/src/server/index.ts            |   1 +
 packages/remix/src/server/instrumentServer.ts |  48 +++++--
 .../server/serverTimingTracePropagation.ts    |  77 ++++++++++
 packages/remix/src/utils/utils.ts             |   6 +
 .../serverTimingTracePropagation.test.ts      | 131 ++++++++++++++++++
 26 files changed, 739 insertions(+), 14 deletions(-)
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-hydrogen/tests/server-timing-header.test.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/.eslintrc.js
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/.gitignore
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/.npmrc
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.server.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/app/root.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/_index.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/redirect-test.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/user.$id.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/globals.d.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/instrument.server.cjs
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/package.json
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/playwright.config.mjs
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/remix.env.d.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/start-event-proxy.mjs
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/tsconfig.json
 create mode 100644 dev-packages/e2e-tests/test-applications/remix-server-timing/vite.config.ts
 create mode 100644 packages/remix/src/server/serverTimingTracePropagation.ts
 create mode 100644 packages/remix/test/server/serverTimingTracePropagation.test.ts

diff --git a/dev-packages/e2e-tests/test-applications/remix-hydrogen/app/entry.server.tsx b/dev-packages/e2e-tests/test-applications/remix-hydrogen/app/entry.server.tsx
index afae990db239..1db0c9e23207 100644
--- a/dev-packages/e2e-tests/test-applications/remix-hydrogen/app/entry.server.tsx
+++ b/dev-packages/e2e-tests/test-applications/remix-hydrogen/app/entry.server.tsx
@@ -1,4 +1,5 @@
 import { RemixServer } from '@remix-run/react';
+import { generateSentryServerTimingHeader } from '@sentry/remix/cloudflare';
 import { createContentSecurityPolicy } from '@shopify/hydrogen';
 import type { EntryContext } from '@shopify/remix-oxygen';
 import isbot from 'isbot';
@@ -43,8 +44,15 @@ export default async function handleRequest(
   // This is required for Sentry's profiling integration
   responseHeaders.set('Document-Policy', 'js-profiling');
 
-  return new Response(body, {
+  const response = new Response(body, {
     headers: responseHeaders,
     status: responseStatusCode,
   });
+
+  const serverTimingValue = generateSentryServerTimingHeader();
+  if (serverTimingValue) {
+    response.headers.append('Server-Timing', serverTimingValue);
+  }
+
+  return response;
 }
diff --git a/dev-packages/e2e-tests/test-applications/remix-hydrogen/tests/server-timing-header.test.ts b/dev-packages/e2e-tests/test-applications/remix-hydrogen/tests/server-timing-header.test.ts
new file mode 100644
index 000000000000..194afa2fa0a4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-hydrogen/tests/server-timing-header.test.ts
@@ -0,0 +1,17 @@
+import { expect, test } from '@playwright/test';
+
+test('Server-Timing header contains sentry-trace on page load', async ({ page }) => {
+  const responsePromise = page.waitForResponse(
+    response =>
+      response.url().endsWith('/') && response.status() === 200 && response.request().resourceType() === 'document',
+  );
+
+  await page.goto('/');
+
+  const response = await responsePromise;
+  const serverTimingHeader = response.headers()['server-timing'];
+
+  expect(serverTimingHeader).toBeDefined();
+  expect(serverTimingHeader).toContain('sentry-trace');
+  expect(serverTimingHeader).toContain('baggage');
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/.eslintrc.js b/dev-packages/e2e-tests/test-applications/remix-server-timing/.eslintrc.js
new file mode 100644
index 000000000000..f2faf1470fd8
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/.eslintrc.js
@@ -0,0 +1,4 @@
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+  extends: ['@remix-run/eslint-config', '@remix-run/eslint-config/node'],
+};
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/.gitignore b/dev-packages/e2e-tests/test-applications/remix-server-timing/.gitignore
new file mode 100644
index 000000000000..a735ebed5b56
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/.gitignore
@@ -0,0 +1,3 @@
+node_modules
+build
+.env
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/.npmrc b/dev-packages/e2e-tests/test-applications/remix-server-timing/.npmrc
new file mode 100644
index 000000000000..070f80f05092
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/.npmrc
@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
new file mode 100644
index 000000000000..85c29d310c1a
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
@@ -0,0 +1,44 @@
+/**
+ * By default, Remix will handle hydrating your app on the client for you.
+ * You are free to delete this file if you'd like to, but if you ever want it revealed again, you can run `npx remix reveal`
+ * For more information, see https://remix.run/file-conventions/entry.client
+ */
+
+// Extend the Window interface to include ENV
+declare global {
+  interface Window {
+    ENV: {
+      SENTRY_DSN: string;
+      [key: string]: unknown;
+    };
+  }
+}
+
+import { RemixBrowser, useLocation, useMatches } from '@remix-run/react';
+import * as Sentry from '@sentry/remix';
+import { StrictMode, startTransition, useEffect } from 'react';
+import { hydrateRoot } from 'react-dom/client';
+
+Sentry.init({
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: window.ENV.SENTRY_DSN,
+  integrations: [
+    Sentry.browserTracingIntegration({
+      useEffect,
+      useLocation,
+      useMatches,
+    }),
+  ],
+  // Performance Monitoring
+  tracesSampleRate: 1.0, // Capture 100% of the transactions
+  tunnel: 'http://localhost:3031/', // proxy server
+});
+
+startTransition(() => {
+  hydrateRoot(
+    document,
+    <StrictMode>
+      <RemixBrowser />
+    </StrictMode>,
+  );
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.server.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.server.tsx
new file mode 100644
index 000000000000..3eb9423dff22
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.server.tsx
@@ -0,0 +1,115 @@
+import * as Sentry from '@sentry/remix';
+
+import { PassThrough } from 'node:stream';
+
+import type { AppLoadContext, EntryContext } from '@remix-run/node';
+import { createReadableStreamFromReadable } from '@remix-run/node';
+import { installGlobals } from '@remix-run/node';
+import { RemixServer } from '@remix-run/react';
+import isbot from 'isbot';
+import { renderToPipeableStream } from 'react-dom/server';
+
+installGlobals();
+
+const ABORT_DELAY = 5_000;
+
+export const handleError = Sentry.sentryHandleError;
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  remixContext: EntryContext,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  loadContext: AppLoadContext,
+) {
+  return isbot(request.headers.get('user-agent'))
+    ? handleBotRequest(request, responseStatusCode, responseHeaders, remixContext)
+    : handleBrowserRequest(request, responseStatusCode, responseHeaders, remixContext);
+}
+
+function handleBotRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  remixContext: EntryContext,
+) {
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    const { pipe, abort } = renderToPipeableStream(
+      <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />,
+      {
+        onAllReady() {
+          shellRendered = true;
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set('Content-Type', 'text/html');
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            }),
+          );
+
+          pipe(body);
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      },
+    );
+
+    setTimeout(abort, ABORT_DELAY);
+  });
+}
+
+function handleBrowserRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  remixContext: EntryContext,
+) {
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    const { pipe, abort } = renderToPipeableStream(
+      <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />,
+      {
+        onShellReady() {
+          shellRendered = true;
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set('Content-Type', 'text/html');
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            }),
+          );
+
+          pipe(body);
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      },
+    );
+
+    setTimeout(abort, ABORT_DELAY);
+  });
+}
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/root.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/root.tsx
new file mode 100644
index 000000000000..beb9fdb70357
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/root.tsx
@@ -0,0 +1,63 @@
+import { cssBundleHref } from '@remix-run/css-bundle';
+import { LinksFunction, json } from '@remix-run/node';
+import {
+  Links,
+  LiveReload,
+  Meta,
+  Outlet,
+  Scripts,
+  ScrollRestoration,
+  useLoaderData,
+  useRouteError,
+} from '@remix-run/react';
+import { captureRemixErrorBoundaryError, withSentry } from '@sentry/remix';
+
+export const links: LinksFunction = () => [...(cssBundleHref ? [{ rel: 'stylesheet', href: cssBundleHref }] : [])];
+
+export const loader = () => {
+  return json({
+    ENV: {
+      SENTRY_DSN: process.env.E2E_TEST_DSN,
+    },
+  });
+};
+
+export function ErrorBoundary() {
+  const error = useRouteError();
+  const eventId = captureRemixErrorBoundaryError(error);
+
+  return (
+    <div>
+      <span>ErrorBoundary Error</span>
+      <span id="event-id">{eventId}</span>
+    </div>
+  );
+}
+
+function App() {
+  const { ENV } = useLoaderData() as { ENV: { SENTRY_DSN: string } };
+
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `window.ENV = ${JSON.stringify(ENV)}`,
+          }}
+        />
+        <Meta />
+        <Links />
+      </head>
+      <body>
+        <Outlet />
+        <ScrollRestoration />
+        <Scripts />
+        <LiveReload />
+      </body>
+    </html>
+  );
+}
+
+export default withSentry(App);
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/_index.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/_index.tsx
new file mode 100644
index 000000000000..89449786a33e
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/_index.tsx
@@ -0,0 +1,28 @@
+import { json, LoaderFunctionArgs } from '@remix-run/node';
+import { Link, useSearchParams } from '@remix-run/react';
+import * as Sentry from '@sentry/remix';
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  return json({});
+};
+
+export default function Index() {
+  const [searchParams] = useSearchParams();
+
+  if (searchParams.get('tag')) {
+    Sentry.setTag('sentry_test', searchParams.get('tag'));
+  }
+
+  return (
+    <div style={{ fontFamily: 'system-ui, sans-serif', lineHeight: '1.8' }}>
+      <h1>Server-Timing Trace Propagation Test</h1>
+      <ul>
+        <li>
+          <Link id="navigation" to="/user/123">
+            Navigate to User 123
+          </Link>
+        </li>
+      </ul>
+    </div>
+  );
+}
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/redirect-test.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/redirect-test.tsx
new file mode 100644
index 000000000000..f41020cf3bca
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/redirect-test.tsx
@@ -0,0 +1,5 @@
+import { redirect } from '@remix-run/node';
+
+export const loader = async () => {
+  return redirect('/user/redirected');
+};
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/user.$id.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/user.$id.tsx
new file mode 100644
index 000000000000..a4ce451adf36
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/routes/user.$id.tsx
@@ -0,0 +1,19 @@
+import { json, LoaderFunctionArgs } from '@remix-run/node';
+import { Link, useLoaderData } from '@remix-run/react';
+
+export const loader = async ({ params }: LoaderFunctionArgs) => {
+  await new Promise(resolve => setTimeout(resolve, 10));
+  return json({ userId: params.id });
+};
+
+export default function User() {
+  const { userId } = useLoaderData<typeof loader>();
+
+  return (
+    <div style={{ fontFamily: 'system-ui, sans-serif', lineHeight: '1.8' }}>
+      <h1>User {userId}</h1>
+      <p>This is a parameterized route for user {userId}.</p>
+      <Link to="/">Back to Home</Link>
+    </div>
+  );
+}
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/globals.d.ts b/dev-packages/e2e-tests/test-applications/remix-server-timing/globals.d.ts
new file mode 100644
index 000000000000..78ed2345c6e4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/globals.d.ts
@@ -0,0 +1,2 @@
+/// <reference types="@remix-run/node" />
+/// <reference types="vite/client" />
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/instrument.server.cjs b/dev-packages/e2e-tests/test-applications/remix-server-timing/instrument.server.cjs
new file mode 100644
index 000000000000..6d211cac4592
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/instrument.server.cjs
@@ -0,0 +1,8 @@
+const Sentry = require('@sentry/remix');
+
+Sentry.init({
+  tracesSampleRate: 1.0, // Capture 100% of the transactions, reduce in production!
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: process.env.E2E_TEST_DSN,
+  tunnel: 'http://localhost:3031/', // proxy server
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/package.json b/dev-packages/e2e-tests/test-applications/remix-server-timing/package.json
new file mode 100644
index 000000000000..d31e86ff0cdc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/package.json
@@ -0,0 +1,42 @@
+{
+  "private": true,
+  "sideEffects": false,
+  "scripts": {
+    "build": "remix vite:build && pnpm typecheck",
+    "dev": "remix vite:dev",
+    "start": "NODE_OPTIONS='--require=./instrument.server.cjs' remix-serve build/server/index.js",
+    "typecheck": "tsc",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm playwright test"
+  },
+  "dependencies": {
+    "@sentry/remix": "latest || *",
+    "@remix-run/css-bundle": "2.17.4",
+    "@remix-run/node": "2.17.4",
+    "@remix-run/react": "2.17.4",
+    "@remix-run/serve": "2.17.4",
+    "isbot": "^3.6.8",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.56.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "@remix-run/dev": "2.17.4",
+    "@remix-run/eslint-config": "2.17.4",
+    "@types/react": "^18.2.64",
+    "@types/react-dom": "^18.2.34",
+    "@types/prop-types": "15.7.7",
+    "eslint": "^8.38.0",
+    "typescript": "^5.1.6",
+    "vite": "^5.4.11",
+    "vite-tsconfig-paths": "^4.2.1"
+  },
+  "resolutions": {
+    "@types/react": "18.2.22"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/remix-server-timing/playwright.config.mjs
new file mode 100644
index 000000000000..b52ff06a5105
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/playwright.config.mjs
@@ -0,0 +1,8 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: 'pnpm start',
+  port: 3030,
+});
+
+export default config;
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/remix.env.d.ts b/dev-packages/e2e-tests/test-applications/remix-server-timing/remix.env.d.ts
new file mode 100644
index 000000000000..dcf8c45e1d4c
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/remix.env.d.ts
@@ -0,0 +1,2 @@
+/// <reference types="@remix-run/dev" />
+/// <reference types="@remix-run/node" />
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/remix-server-timing/start-event-proxy.mjs
new file mode 100644
index 000000000000..2fbbf5087be1
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'remix-server-timing',
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts b/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts
new file mode 100644
index 000000000000..2327b96ff928
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts
@@ -0,0 +1,73 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('propagates trace context from server-timing header to client pageload', async ({ page }) => {
+  const testTag = crypto.randomUUID();
+
+  const responsePromise = page.waitForResponse(
+    response => response.url().includes(`tag=${testTag}`) && response.status() === 200,
+  );
+
+  const pageLoadTransactionPromise = waitForTransaction('remix-server-timing', transactionEvent => {
+    return transactionEvent.contexts?.trace?.op === 'pageload' && transactionEvent.tags?.['sentry_test'] === testTag;
+  });
+
+  await page.goto(`/?tag=${testTag}`);
+
+  const response = await responsePromise;
+  const serverTimingHeader = response.headers()['server-timing'];
+
+  expect(serverTimingHeader).toBeDefined();
+  expect(serverTimingHeader).toContain('sentry-trace');
+  expect(serverTimingHeader).toContain('baggage');
+
+  const sentryTraceMatch = serverTimingHeader?.match(/sentry-trace;desc="([^"]+)"/);
+  expect(sentryTraceMatch).toBeTruthy();
+  const [headerTraceId, headerSpanId, headerSampled] = sentryTraceMatch?.[1]?.split('-') || [];
+
+  expect(headerTraceId).toHaveLength(32);
+  expect(headerSpanId).toHaveLength(16);
+  expect(headerSampled).toBe('1');
+
+  const pageloadTransaction = await pageLoadTransactionPromise;
+
+  expect(pageloadTransaction).toBeDefined();
+  expect(pageloadTransaction.transaction).toBe('/');
+
+  expect(pageloadTransaction.contexts?.trace?.trace_id).toEqual(headerTraceId);
+  expect(pageloadTransaction.contexts?.trace?.parent_span_id).toEqual(headerSpanId);
+});
+
+test('includes server-timing header on redirect responses', async ({ page }) => {
+  const redirectResponsePromise = page.waitForResponse(response => response.url().includes('/redirect-test'));
+
+  await page.goto('/redirect-test');
+
+  const redirectResponse = await redirectResponsePromise;
+  const serverTimingHeader = redirectResponse.headers()['server-timing'];
+
+  expect(serverTimingHeader).toBeDefined();
+  expect(serverTimingHeader).toContain('sentry-trace');
+
+  const sentryTraceMatch = serverTimingHeader?.match(/sentry-trace;desc="([^"]+)"/);
+  expect(sentryTraceMatch).toBeTruthy();
+  const [traceId, spanId] = sentryTraceMatch![1].split('-');
+  expect(traceId).toHaveLength(32);
+  expect(spanId).toHaveLength(16);
+
+  await page.waitForURL(/\/user\/redirected/);
+  await expect(page.locator('h1')).toContainText('User redirected');
+});
+
+test('excludes server-timing header from client-side navigation data fetches', async ({ page }) => {
+  await page.goto('/');
+  await page.locator('#navigation').waitFor({ state: 'visible' });
+
+  const navDataFetchPromise = page.waitForResponse(
+    response =>
+      response.url().includes('/user/123') && (response.url().includes('_data=') || response.url().endsWith('.data')),
+  );
+  await page.click('#navigation');
+  const navDataFetch = await navDataFetchPromise;
+  expect(navDataFetch.headers()['server-timing']).toBeUndefined();
+});
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/tsconfig.json b/dev-packages/e2e-tests/test-applications/remix-server-timing/tsconfig.json
new file mode 100644
index 000000000000..91f6b263f2c7
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/tsconfig.json
@@ -0,0 +1,23 @@
+{
+  "include": ["remix.env.d.ts", "**/*.ts", "**/*.tsx", "globals.d.ts"],
+  "compilerOptions": {
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "types": ["@remix-run/node", "vite/client"],
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "target": "ES2022",
+    "strict": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./app/*"]
+    },
+    "noEmit": true
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/vite.config.ts b/dev-packages/e2e-tests/test-applications/remix-server-timing/vite.config.ts
new file mode 100644
index 000000000000..d4d7f23895c1
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/vite.config.ts
@@ -0,0 +1,15 @@
+import { vitePlugin as remix } from '@remix-run/dev';
+import { sentryRemixVitePlugin } from '@sentry/remix';
+import { defineConfig } from 'vite';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig({
+  plugins: [
+    remix({
+      ignoredRouteFiles: ['**/.*'],
+      serverModuleFormat: 'cjs',
+    }),
+    sentryRemixVitePlugin(),
+    tsconfigPaths(),
+  ],
+});
diff --git a/packages/remix/src/cloudflare/index.ts b/packages/remix/src/cloudflare/index.ts
index 9b78855ae2d3..ede127a694ce 100644
--- a/packages/remix/src/cloudflare/index.ts
+++ b/packages/remix/src/cloudflare/index.ts
@@ -13,6 +13,7 @@ export { captureRemixErrorBoundaryError } from '../client/errors';
 export { withSentry } from '../client/performance';
 export { ErrorBoundary, browserTracingIntegration } from '../client';
 export { makeWrappedCreateRequestHandler, sentryHandleError };
+export { generateSentryServerTimingHeader } from '../server/serverTimingTracePropagation';
 
 /**
  * Instruments a Remix build to capture errors and performance data.
diff --git a/packages/remix/src/server/index.ts b/packages/remix/src/server/index.ts
index 1533a1ca7221..cafec61ac9af 100644
--- a/packages/remix/src/server/index.ts
+++ b/packages/remix/src/server/index.ts
@@ -139,3 +139,4 @@ export * from '@sentry/node';
 export { init, getRemixDefaultIntegrations } from './sdk';
 export { captureRemixServerException } from './errors';
 export { sentryHandleError, wrapHandleErrorWithSentry, instrumentBuild } from './instrumentServer';
+export { generateSentryServerTimingHeader } from './serverTimingTracePropagation';
diff --git a/packages/remix/src/server/instrumentServer.ts b/packages/remix/src/server/instrumentServer.ts
index d8864d254a99..d768c87c62a8 100644
--- a/packages/remix/src/server/instrumentServer.ts
+++ b/packages/remix/src/server/instrumentServer.ts
@@ -36,9 +36,10 @@ import {
   withIsolationScope,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../utils/debug-build';
-import { createRoutes, getTransactionName } from '../utils/utils';
+import { createRoutes, getTransactionName, isCloudflareEnv } from '../utils/utils';
 import { extractData, isResponse, json } from '../utils/vendor/response';
 import { captureRemixServerException, errorHandleDataFunction } from './errors';
+import { generateSentryServerTimingHeader, injectServerTimingHeaderValue } from './serverTimingTracePropagation';
 
 type AppData = unknown;
 type RemixRequest = Parameters<RequestHandler>[0];
@@ -95,11 +96,6 @@ export function wrapHandleErrorWithSentry(
   };
 }
 
-function isCloudflareEnv(): boolean {
-  // eslint-disable-next-line no-restricted-globals
-  return navigator?.userAgent?.includes('Cloudflare');
-}
-
 function getTraceAndBaggage(): {
   sentryTrace?: string;
   sentryBaggage?: string;
@@ -119,13 +115,17 @@ function getTraceAndBaggage(): {
 function makeWrappedDocumentRequestFunction(instrumentTracing?: boolean) {
   return function (origDocumentRequestFunction: HandleDocumentRequestFunction): HandleDocumentRequestFunction {
     return async function (this: unknown, request: Request, ...args: unknown[]): Promise<Response> {
-      if (instrumentTracing) {
-        const activeSpan = getActiveSpan();
-        const rootSpan = activeSpan && getRootSpan(activeSpan);
+      const activeSpan = getActiveSpan();
+      const rootSpan = activeSpan && getRootSpan(activeSpan);
+
+      const serverTimingHeader = rootSpan ? generateSentryServerTimingHeader(rootSpan) : null;
 
+      let response: Response;
+
+      if (instrumentTracing) {
         const name = rootSpan ? spanToJSON(rootSpan).description : undefined;
 
-        return startSpan(
+        response = await startSpan(
           {
             // If we don't have a root span, `onlyIfParent` will lead to the span not being created anyhow
             // So we don't need to care too much about the fallback name, it's just for typing purposes....
@@ -143,8 +143,14 @@ function makeWrappedDocumentRequestFunction(instrumentTracing?: boolean) {
           },
         );
       } else {
-        return origDocumentRequestFunction.call(this, request, ...args);
+        response = await origDocumentRequestFunction.call(this, request, ...args);
+      }
+
+      if (serverTimingHeader && response instanceof Response) {
+        return injectServerTimingHeaderValue(response, serverTimingHeader);
       }
+
+      return response;
     };
   };
 }
@@ -186,13 +192,15 @@ function makeWrappedDataFunction(
   build?: ServerBuild,
 ): DataFunction {
   return async function (this: unknown, args: DataFunctionArgs): Promise<Response | AppData> {
+    let res: Response | AppData;
+
     if (instrumentTracing) {
       // Update span name for Cloudflare Workers/Hydrogen environments
       if (build) {
         updateSpanWithRoute(args, build);
       }
 
-      return startSpan(
+      res = await startSpan(
         {
           op: `function.remix.${name}`,
           name: id,
@@ -207,8 +215,22 @@ function makeWrappedDataFunction(
         },
       );
     } else {
-      return errorHandleDataFunction.call(this, origFn, name, args);
+      res = await errorHandleDataFunction.call(this, origFn, name, args);
+    }
+
+    // Redirects bypass makeWrappedDocumentRequestFunction, so we inject Server-Timing here.
+    if (isResponse(res) && isRedirectResponse(res)) {
+      const activeSpan = getActiveSpan();
+      const rootSpan = activeSpan && getRootSpan(activeSpan);
+      if (rootSpan) {
+        const serverTimingHeader = generateSentryServerTimingHeader(rootSpan);
+        if (serverTimingHeader) {
+          return injectServerTimingHeaderValue(res, serverTimingHeader);
+        }
+      }
     }
+
+    return res;
   };
 }
 
diff --git a/packages/remix/src/server/serverTimingTracePropagation.ts b/packages/remix/src/server/serverTimingTracePropagation.ts
new file mode 100644
index 000000000000..aaefaa612922
--- /dev/null
+++ b/packages/remix/src/server/serverTimingTracePropagation.ts
@@ -0,0 +1,77 @@
+import type { Span } from '@sentry/core';
+import {
+  debug,
+  getActiveSpan,
+  getRootSpan,
+  getTraceData,
+  isNodeEnv,
+  spanToBaggageHeader,
+  spanToTraceHeader,
+} from '@sentry/core';
+import { DEBUG_BUILD } from '../utils/debug-build';
+import { isCloudflareEnv } from '../utils/utils';
+
+/** Generate a Server-Timing header value containing Sentry trace context. */
+export function generateSentryServerTimingHeader(span?: Span): string | null {
+  if (!isNodeEnv() && !isCloudflareEnv()) {
+    return null;
+  }
+
+  try {
+    let resolvedSpan = span;
+    if (!resolvedSpan) {
+      const activeSpan = getActiveSpan();
+      if (activeSpan) {
+        resolvedSpan = getRootSpan(activeSpan);
+      }
+    }
+
+    let sentryTrace: string | undefined;
+    let baggage: string | undefined;
+
+    if (resolvedSpan) {
+      sentryTrace = spanToTraceHeader(resolvedSpan);
+      baggage = spanToBaggageHeader(resolvedSpan);
+    } else {
+      const traceData = getTraceData();
+      sentryTrace = traceData['sentry-trace'];
+      baggage = traceData.baggage;
+    }
+
+    if (!sentryTrace) {
+      return null;
+    }
+
+    const parts: string[] = [];
+
+    parts.push(`sentry-trace;desc="${sentryTrace}"`);
+
+    if (baggage) {
+      parts.push(`baggage;desc="${baggage}"`);
+    }
+
+    return parts.join(', ');
+  } catch (e) {
+    DEBUG_BUILD && debug.warn('Failed to generate Server-Timing header', e);
+    return null;
+  }
+}
+
+/** @internal */
+export function injectServerTimingHeaderValue(response: Response, serverTimingValue: string): Response {
+  try {
+    const headers = new Headers(response.headers);
+    const existing = headers.get('Server-Timing');
+
+    headers.set('Server-Timing', existing ? `${existing}, ${serverTimingValue}` : serverTimingValue);
+
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  } catch (e) {
+    DEBUG_BUILD && debug.warn('Failed to add Server-Timing header to response', e);
+    return response;
+  }
+}
diff --git a/packages/remix/src/utils/utils.ts b/packages/remix/src/utils/utils.ts
index c179bc43f61f..2e9fa21687bc 100644
--- a/packages/remix/src/utils/utils.ts
+++ b/packages/remix/src/utils/utils.ts
@@ -109,6 +109,12 @@ export function convertRemixRouteIdToPath(routeId: string): string {
   return routePath;
 }
 
+/** Check if running in Cloudflare Workers environment. */
+export function isCloudflareEnv(): boolean {
+  // eslint-disable-next-line no-restricted-globals
+  return typeof navigator !== 'undefined' && navigator?.userAgent?.includes('Cloudflare');
+}
+
 /**
  * Get transaction name from routes and url
  */
diff --git a/packages/remix/test/server/serverTimingTracePropagation.test.ts b/packages/remix/test/server/serverTimingTracePropagation.test.ts
new file mode 100644
index 000000000000..6731b948f98e
--- /dev/null
+++ b/packages/remix/test/server/serverTimingTracePropagation.test.ts
@@ -0,0 +1,131 @@
+import { getActiveSpan, getTraceData, isNodeEnv, spanToBaggageHeader, spanToTraceHeader } from '@sentry/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  generateSentryServerTimingHeader,
+  injectServerTimingHeaderValue,
+} from '../../src/server/serverTimingTracePropagation';
+
+const mockSpan = {
+  spanId: 'test-span-id',
+  spanContext: () => ({ traceId: '12345678901234567890123456789012' }),
+};
+const mockRootSpan = {
+  spanId: 'root-span-id',
+  spanContext: () => ({ traceId: '12345678901234567890123456789012' }),
+};
+
+vi.mock('@sentry/core', () => ({
+  debug: {
+    log: vi.fn(),
+    warn: vi.fn(),
+  },
+  getActiveSpan: vi.fn(),
+  getRootSpan: vi.fn(() => mockRootSpan),
+  getTraceData: vi.fn(() => ({
+    'sentry-trace': '12345678901234567890123456789012-1234567890123456-1',
+    baggage: 'sentry-environment=production,sentry-release=1.0.0',
+  })),
+  spanToTraceHeader: vi.fn(() => '12345678901234567890123456789012-1234567890123456-1'),
+  spanToBaggageHeader: vi.fn(() => 'sentry-environment=production,sentry-release=1.0.0'),
+  isNodeEnv: vi.fn(() => true),
+}));
+
+describe('serverTimingTracePropagation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(isNodeEnv).mockReturnValue(true);
+    vi.mocked(getActiveSpan).mockReturnValue(mockSpan);
+  });
+
+  describe('generateSentryServerTimingHeader', () => {
+    it('returns null in browser environments', () => {
+      vi.mocked(isNodeEnv).mockReturnValue(false);
+
+      expect(generateSentryServerTimingHeader()).toBeNull();
+    });
+
+    it('returns null without trace data', () => {
+      vi.mocked(getActiveSpan).mockReturnValue(undefined);
+      vi.mocked(getTraceData).mockReturnValue({});
+
+      expect(generateSentryServerTimingHeader()).toBeNull();
+    });
+
+    it('produces correct Server-Timing format', () => {
+      const result = generateSentryServerTimingHeader();
+
+      expect(result).toBe(
+        'sentry-trace;desc="12345678901234567890123456789012-1234567890123456-1", baggage;desc="sentry-environment=production,sentry-release=1.0.0"',
+      );
+    });
+
+    it('falls back to getTraceData without active span', () => {
+      vi.mocked(getActiveSpan).mockReturnValue(undefined);
+      vi.mocked(getTraceData).mockReturnValue({
+        'sentry-trace': 'fallback-trace-id-1234567890123456-0',
+        baggage: 'sentry-fallback=true',
+      });
+
+      const result = generateSentryServerTimingHeader();
+
+      expect(result).toContain('sentry-trace;desc="fallback-trace-id-1234567890123456-0"');
+      expect(result).toContain('sentry-fallback=true');
+    });
+
+    it('uses the provided span directly instead of resolving from active span', () => {
+      const directSpan = { spanId: 'direct-span-id', spanContext: () => ({ traceId: 'abc' }) };
+
+      const result = generateSentryServerTimingHeader(directSpan as any);
+
+      expect(spanToTraceHeader).toHaveBeenCalledWith(directSpan);
+      expect(spanToBaggageHeader).toHaveBeenCalledWith(directSpan);
+      expect(result).toBeDefined();
+    });
+
+    it('generates header in Cloudflare environment when isNodeEnv is false', () => {
+      vi.mocked(isNodeEnv).mockReturnValue(false);
+
+      const originalNavigator = globalThis.navigator;
+      Object.defineProperty(globalThis, 'navigator', {
+        value: { userAgent: 'Cloudflare' },
+        configurable: true,
+      });
+
+      const result = generateSentryServerTimingHeader();
+      expect(result).not.toBeNull();
+
+      // Restore
+      Object.defineProperty(globalThis, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    });
+  });
+
+  describe('injectServerTimingHeaderValue', () => {
+    it('adds Server-Timing header to response', () => {
+      const mockResponse = new Response('test body', {
+        status: 200,
+        statusText: 'OK',
+        headers: new Headers(),
+      });
+
+      const result = injectServerTimingHeaderValue(mockResponse, 'sentry-trace;desc="test"');
+
+      expect(result.headers.get('Server-Timing')).toBe('sentry-trace;desc="test"');
+      expect(result.status).toBe(200);
+      expect(result.statusText).toBe('OK');
+    });
+
+    it('merges with existing Server-Timing header', () => {
+      const mockResponse = new Response('test body', {
+        status: 200,
+        headers: new Headers({ 'Server-Timing': 'cache;dur=100' }),
+      });
+
+      const result = injectServerTimingHeaderValue(mockResponse, 'sentry-trace;desc="test"');
+
+      expect(result.headers.get('Server-Timing')).toBe('cache;dur=100, sentry-trace;desc="test"');
+    });
+  });
+});

From 3fdd1114b76b67af902174aa8e4fde0a687a8273 Mon Sep 17 00:00:00 2001
From: Onur Temizkan <onur@narval.co.uk>
Date: Mon, 23 Feb 2026 15:01:34 +0000
Subject: [PATCH 2/6] Prevent duplicate Server-Timing header entries in
 Cloudflare

---
 .../src/server/serverTimingTracePropagation.ts |  5 +++++
 .../serverTimingTracePropagation.test.ts       | 18 ++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/packages/remix/src/server/serverTimingTracePropagation.ts b/packages/remix/src/server/serverTimingTracePropagation.ts
index aaefaa612922..af564b1c0b20 100644
--- a/packages/remix/src/server/serverTimingTracePropagation.ts
+++ b/packages/remix/src/server/serverTimingTracePropagation.ts
@@ -63,6 +63,11 @@ export function injectServerTimingHeaderValue(response: Response, serverTimingVa
     const headers = new Headers(response.headers);
     const existing = headers.get('Server-Timing');
 
+    // Avoid duplicate entries when manually injected in entry.server.tsx
+    if (existing?.includes('sentry-trace')) {
+      return response;
+    }
+
     headers.set('Server-Timing', existing ? `${existing}, ${serverTimingValue}` : serverTimingValue);
 
     return new Response(response.body, {
diff --git a/packages/remix/test/server/serverTimingTracePropagation.test.ts b/packages/remix/test/server/serverTimingTracePropagation.test.ts
index 6731b948f98e..0e19b08ccd57 100644
--- a/packages/remix/test/server/serverTimingTracePropagation.test.ts
+++ b/packages/remix/test/server/serverTimingTracePropagation.test.ts
@@ -127,5 +127,23 @@ describe('serverTimingTracePropagation', () => {
 
       expect(result.headers.get('Server-Timing')).toBe('cache;dur=100, sentry-trace;desc="test"');
     });
+
+    it('skips injection when sentry-trace already exists in Server-Timing header', () => {
+      const mockResponse = new Response('test body', {
+        status: 200,
+        headers: new Headers({
+          'Server-Timing': 'sentry-trace;desc="existing-trace", baggage;desc="existing-baggage"',
+        }),
+      });
+
+      const result = injectServerTimingHeaderValue(
+        mockResponse,
+        'sentry-trace;desc="new-trace", baggage;desc="new-baggage"',
+      );
+
+      expect(result.headers.get('Server-Timing')).toBe(
+        'sentry-trace;desc="existing-trace", baggage;desc="existing-baggage"',
+      );
+    });
   });
 });

From 15fface19f747e61540cb33eb4aaab2a7ae8209f Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Wed, 18 Mar 2026 15:42:29 +0100
Subject: [PATCH 3/6] fix incorrect getTraceData usage as well as fix a bug in
 propagator

---
 .../remix-server-timing/app/entry.client.tsx  | 12 +++----
 .../server-timing-trace-propagation.test.ts   | 36 +++++++++++++++++--
 .../opentelemetry/src/utils/getTraceData.ts   |  2 +-
 .../server/serverTimingTracePropagation.ts    | 32 +++--------------
 4 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
index 85c29d310c1a..816718844fd7 100644
--- a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
@@ -14,13 +14,13 @@ declare global {
   }
 }
 
-import { RemixBrowser, useLocation, useMatches } from '@remix-run/react';
-import * as Sentry from '@sentry/remix';
-import { StrictMode, startTransition, useEffect } from 'react';
-import { hydrateRoot } from 'react-dom/client';
+import { RemixBrowser, useLocation, useMatches } from "@remix-run/react";
+import * as Sentry from "@sentry/remix";
+import { StrictMode, startTransition, useEffect } from "react";
+import { hydrateRoot } from "react-dom/client";
 
 Sentry.init({
-  environment: 'qa', // dynamic sampling bias to keep transactions
+  environment: "qa", // dynamic sampling bias to keep transactions
   dsn: window.ENV.SENTRY_DSN,
   integrations: [
     Sentry.browserTracingIntegration({
@@ -31,7 +31,7 @@ Sentry.init({
   ],
   // Performance Monitoring
   tracesSampleRate: 1.0, // Capture 100% of the transactions
-  tunnel: 'http://localhost:3031/', // proxy server
+  tunnel: "http://localhost:3031/", // proxy server
 });
 
 startTransition(() => {
diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts b/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts
index 2327b96ff928..38b53d2bcc90 100644
--- a/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/tests/server-timing-trace-propagation.test.ts
@@ -12,6 +12,10 @@ test('propagates trace context from server-timing header to client pageload', as
     return transactionEvent.contexts?.trace?.op === 'pageload' && transactionEvent.tags?.['sentry_test'] === testTag;
   });
 
+  const httpServerTransactionPromise = waitForTransaction('remix-server-timing', transactionEvent => {
+    return transactionEvent.contexts?.trace?.op === 'http.server';
+  });
+
   await page.goto(`/?tag=${testTag}`);
 
   const response = await responsePromise;
@@ -30,25 +34,46 @@ test('propagates trace context from server-timing header to client pageload', as
   expect(headerSampled).toBe('1');
 
   const pageloadTransaction = await pageLoadTransactionPromise;
+  const httpServerTransaction = await httpServerTransactionPromise;
 
   expect(pageloadTransaction).toBeDefined();
   expect(pageloadTransaction.transaction).toBe('/');
 
+  expect(httpServerTransaction.transaction).toMatch(/^GET http:\/\/localhost:\d+\/$/);
+
   expect(pageloadTransaction.contexts?.trace?.trace_id).toEqual(headerTraceId);
   expect(pageloadTransaction.contexts?.trace?.parent_span_id).toEqual(headerSpanId);
+
+  expect(httpServerTransaction.contexts?.trace?.trace_id).toEqual(headerTraceId);
+  expect(httpServerTransaction.contexts?.trace?.span_id).toEqual(headerSpanId);
 });
 
 test('includes server-timing header on redirect responses', async ({ page }) => {
   const redirectResponsePromise = page.waitForResponse(response => response.url().includes('/redirect-test'));
+  const redirectedPageloadResponsePromise = page.waitForResponse(response =>
+    response.url().includes('/user/redirected'),
+  );
+
+  const pageLoadTransactionPromise = waitForTransaction('remix-server-timing', transactionEvent => {
+    return transactionEvent.contexts?.trace?.op === 'pageload';
+  });
 
   await page.goto('/redirect-test');
 
   const redirectResponse = await redirectResponsePromise;
-  const serverTimingHeader = redirectResponse.headers()['server-timing'];
+  const redirectServerTimingHeader = redirectResponse.headers()['server-timing'];
 
-  expect(serverTimingHeader).toBeDefined();
-  expect(serverTimingHeader).toContain('sentry-trace');
+  expect(redirectServerTimingHeader).toBeDefined();
+  expect(redirectServerTimingHeader).toContain('sentry-trace');
+  expect(redirectServerTimingHeader).toContain('baggage');
 
+  const redirectSentryTraceMatch = redirectServerTimingHeader?.match(/sentry-trace;desc="([^"]+)"/);
+  expect(redirectSentryTraceMatch).toBeTruthy();
+  expect(redirectSentryTraceMatch![1]).toMatch(/[a-f0-9]{32}-[a-f0-9]{16}-1/);
+
+  const redirectedPageloadResponse = await redirectedPageloadResponsePromise;
+
+  const serverTimingHeader = redirectedPageloadResponse.headers()['server-timing'];
   const sentryTraceMatch = serverTimingHeader?.match(/sentry-trace;desc="([^"]+)"/);
   expect(sentryTraceMatch).toBeTruthy();
   const [traceId, spanId] = sentryTraceMatch![1].split('-');
@@ -57,6 +82,11 @@ test('includes server-timing header on redirect responses', async ({ page }) =>
 
   await page.waitForURL(/\/user\/redirected/);
   await expect(page.locator('h1')).toContainText('User redirected');
+
+  const pageLoadTransaction = await pageLoadTransactionPromise;
+  expect(pageLoadTransaction.transaction).toBe('/user/:id');
+  expect(pageLoadTransaction.contexts?.trace?.trace_id).toEqual(traceId);
+  expect(pageLoadTransaction.contexts?.trace?.parent_span_id).toEqual(spanId);
 });
 
 test('excludes server-timing header from client-side navigation data fetches', async ({ page }) => {
diff --git a/packages/opentelemetry/src/utils/getTraceData.ts b/packages/opentelemetry/src/utils/getTraceData.ts
index cae4059cf9e1..eec035ecd53f 100644
--- a/packages/opentelemetry/src/utils/getTraceData.ts
+++ b/packages/opentelemetry/src/utils/getTraceData.ts
@@ -24,7 +24,7 @@ export function getTraceData({
   if (span) {
     const { scope } = getCapturedScopesOnSpan(span);
     // fall back to current context if for whatever reason we can't find the one of the span
-    ctx = (scope && getContextFromScope(scope)) || api.trace.setSpan(api.context.active(), span);
+    ctx = api.trace.setSpan(api.context.active(), span) || (scope && getContextFromScope(scope));
   }
 
   const { traceId, spanId, sampled, dynamicSamplingContext } = getInjectionData(ctx, { scope, client });
diff --git a/packages/remix/src/server/serverTimingTracePropagation.ts b/packages/remix/src/server/serverTimingTracePropagation.ts
index af564b1c0b20..f8f3c148d1b9 100644
--- a/packages/remix/src/server/serverTimingTracePropagation.ts
+++ b/packages/remix/src/server/serverTimingTracePropagation.ts
@@ -1,13 +1,5 @@
 import type { Span } from '@sentry/core';
-import {
-  debug,
-  getActiveSpan,
-  getRootSpan,
-  getTraceData,
-  isNodeEnv,
-  spanToBaggageHeader,
-  spanToTraceHeader,
-} from '@sentry/core';
+import { debug, getTraceData, isNodeEnv } from '@sentry/core';
 import { DEBUG_BUILD } from '../utils/debug-build';
 import { isCloudflareEnv } from '../utils/utils';
 
@@ -18,25 +10,9 @@ export function generateSentryServerTimingHeader(span?: Span): string | null {
   }
 
   try {
-    let resolvedSpan = span;
-    if (!resolvedSpan) {
-      const activeSpan = getActiveSpan();
-      if (activeSpan) {
-        resolvedSpan = getRootSpan(activeSpan);
-      }
-    }
-
-    let sentryTrace: string | undefined;
-    let baggage: string | undefined;
-
-    if (resolvedSpan) {
-      sentryTrace = spanToTraceHeader(resolvedSpan);
-      baggage = spanToBaggageHeader(resolvedSpan);
-    } else {
-      const traceData = getTraceData();
-      sentryTrace = traceData['sentry-trace'];
-      baggage = traceData.baggage;
-    }
+    const traceData = getTraceData({ span });
+    const sentryTrace = traceData['sentry-trace'];
+    const baggage = traceData.baggage;
 
     if (!sentryTrace) {
       return null;

From aa83a81489fb76c0af9792dd6938ccc5c72f49f5 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Wed, 18 Mar 2026 15:43:57 +0100
Subject: [PATCH 4/6] lint fix

---
 .../remix-server-timing/app/entry.client.tsx         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
index 816718844fd7..85c29d310c1a 100644
--- a/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
+++ b/dev-packages/e2e-tests/test-applications/remix-server-timing/app/entry.client.tsx
@@ -14,13 +14,13 @@ declare global {
   }
 }
 
-import { RemixBrowser, useLocation, useMatches } from "@remix-run/react";
-import * as Sentry from "@sentry/remix";
-import { StrictMode, startTransition, useEffect } from "react";
-import { hydrateRoot } from "react-dom/client";
+import { RemixBrowser, useLocation, useMatches } from '@remix-run/react';
+import * as Sentry from '@sentry/remix';
+import { StrictMode, startTransition, useEffect } from 'react';
+import { hydrateRoot } from 'react-dom/client';
 
 Sentry.init({
-  environment: "qa", // dynamic sampling bias to keep transactions
+  environment: 'qa', // dynamic sampling bias to keep transactions
   dsn: window.ENV.SENTRY_DSN,
   integrations: [
     Sentry.browserTracingIntegration({
@@ -31,7 +31,7 @@ Sentry.init({
   ],
   // Performance Monitoring
   tracesSampleRate: 1.0, // Capture 100% of the transactions
-  tunnel: "http://localhost:3031/", // proxy server
+  tunnel: 'http://localhost:3031/', // proxy server
 });
 
 startTransition(() => {

From cab07991c93de29436631f4f423bba2e67966252 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Wed, 18 Mar 2026 16:32:15 +0100
Subject: [PATCH 5/6] the simpler, the better

---
 .../opentelemetry/src/utils/getTraceData.ts     |  2 +-
 packages/remix/src/server/instrumentServer.ts   | 17 ++++++-----------
 .../src/server/serverTimingTracePropagation.ts  |  4 ++--
 .../server/serverTimingTracePropagation.test.ts | 10 ----------
 4 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/packages/opentelemetry/src/utils/getTraceData.ts b/packages/opentelemetry/src/utils/getTraceData.ts
index eec035ecd53f..cae4059cf9e1 100644
--- a/packages/opentelemetry/src/utils/getTraceData.ts
+++ b/packages/opentelemetry/src/utils/getTraceData.ts
@@ -24,7 +24,7 @@ export function getTraceData({
   if (span) {
     const { scope } = getCapturedScopesOnSpan(span);
     // fall back to current context if for whatever reason we can't find the one of the span
-    ctx = api.trace.setSpan(api.context.active(), span) || (scope && getContextFromScope(scope));
+    ctx = (scope && getContextFromScope(scope)) || api.trace.setSpan(api.context.active(), span);
   }
 
   const { traceId, spanId, sampled, dynamicSamplingContext } = getInjectionData(ctx, { scope, client });
diff --git a/packages/remix/src/server/instrumentServer.ts b/packages/remix/src/server/instrumentServer.ts
index d768c87c62a8..f4b19926f802 100644
--- a/packages/remix/src/server/instrumentServer.ts
+++ b/packages/remix/src/server/instrumentServer.ts
@@ -115,14 +115,13 @@ function getTraceAndBaggage(): {
 function makeWrappedDocumentRequestFunction(instrumentTracing?: boolean) {
   return function (origDocumentRequestFunction: HandleDocumentRequestFunction): HandleDocumentRequestFunction {
     return async function (this: unknown, request: Request, ...args: unknown[]): Promise<Response> {
-      const activeSpan = getActiveSpan();
-      const rootSpan = activeSpan && getRootSpan(activeSpan);
-
-      const serverTimingHeader = rootSpan ? generateSentryServerTimingHeader(rootSpan) : null;
+      const serverTimingHeader = generateSentryServerTimingHeader();
 
       let response: Response;
 
       if (instrumentTracing) {
+        const activeSpan = getActiveSpan();
+        const rootSpan = activeSpan && getRootSpan(activeSpan);
         const name = rootSpan ? spanToJSON(rootSpan).description : undefined;
 
         response = await startSpan(
@@ -220,13 +219,9 @@ function makeWrappedDataFunction(
 
     // Redirects bypass makeWrappedDocumentRequestFunction, so we inject Server-Timing here.
     if (isResponse(res) && isRedirectResponse(res)) {
-      const activeSpan = getActiveSpan();
-      const rootSpan = activeSpan && getRootSpan(activeSpan);
-      if (rootSpan) {
-        const serverTimingHeader = generateSentryServerTimingHeader(rootSpan);
-        if (serverTimingHeader) {
-          return injectServerTimingHeaderValue(res, serverTimingHeader);
-        }
+      const serverTimingHeader = generateSentryServerTimingHeader();
+      if (serverTimingHeader) {
+        return injectServerTimingHeaderValue(res, serverTimingHeader);
       }
     }
 
diff --git a/packages/remix/src/server/serverTimingTracePropagation.ts b/packages/remix/src/server/serverTimingTracePropagation.ts
index f8f3c148d1b9..fd8440f3578d 100644
--- a/packages/remix/src/server/serverTimingTracePropagation.ts
+++ b/packages/remix/src/server/serverTimingTracePropagation.ts
@@ -4,13 +4,13 @@ import { DEBUG_BUILD } from '../utils/debug-build';
 import { isCloudflareEnv } from '../utils/utils';
 
 /** Generate a Server-Timing header value containing Sentry trace context. */
-export function generateSentryServerTimingHeader(span?: Span): string | null {
+export function generateSentryServerTimingHeader(): string | null {
   if (!isNodeEnv() && !isCloudflareEnv()) {
     return null;
   }
 
   try {
-    const traceData = getTraceData({ span });
+    const traceData = getTraceData();
     const sentryTrace = traceData['sentry-trace'];
     const baggage = traceData.baggage;
 
diff --git a/packages/remix/test/server/serverTimingTracePropagation.test.ts b/packages/remix/test/server/serverTimingTracePropagation.test.ts
index 0e19b08ccd57..dd527449736b 100644
--- a/packages/remix/test/server/serverTimingTracePropagation.test.ts
+++ b/packages/remix/test/server/serverTimingTracePropagation.test.ts
@@ -72,16 +72,6 @@ describe('serverTimingTracePropagation', () => {
       expect(result).toContain('sentry-fallback=true');
     });
 
-    it('uses the provided span directly instead of resolving from active span', () => {
-      const directSpan = { spanId: 'direct-span-id', spanContext: () => ({ traceId: 'abc' }) };
-
-      const result = generateSentryServerTimingHeader(directSpan as any);
-
-      expect(spanToTraceHeader).toHaveBeenCalledWith(directSpan);
-      expect(spanToBaggageHeader).toHaveBeenCalledWith(directSpan);
-      expect(result).toBeDefined();
-    });
-
     it('generates header in Cloudflare environment when isNodeEnv is false', () => {
       vi.mocked(isNodeEnv).mockReturnValue(false);
 

From 9aa98ee8949e42613196dedbc9025ef2b134d049 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Wed, 18 Mar 2026 17:02:29 +0100
Subject: [PATCH 6/6] fix unit tests

---
 .../server/serverTimingTracePropagation.test.ts  | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/packages/remix/test/server/serverTimingTracePropagation.test.ts b/packages/remix/test/server/serverTimingTracePropagation.test.ts
index dd527449736b..7e9852e97c6b 100644
--- a/packages/remix/test/server/serverTimingTracePropagation.test.ts
+++ b/packages/remix/test/server/serverTimingTracePropagation.test.ts
@@ -35,18 +35,22 @@ describe('serverTimingTracePropagation', () => {
     vi.clearAllMocks();
     vi.mocked(isNodeEnv).mockReturnValue(true);
     vi.mocked(getActiveSpan).mockReturnValue(mockSpan);
+    vi.mocked(getTraceData).mockReturnValue({
+      'sentry-trace': '12345678901234567890123456789012-1234567890123456-1',
+      baggage: 'sentry-environment=production,sentry-release=1.0.0',
+    });
   });
 
   describe('generateSentryServerTimingHeader', () => {
     it('returns null in browser environments', () => {
-      vi.mocked(isNodeEnv).mockReturnValue(false);
+      vi.mocked(isNodeEnv).mockReturnValueOnce(false);
 
       expect(generateSentryServerTimingHeader()).toBeNull();
     });
 
     it('returns null without trace data', () => {
-      vi.mocked(getActiveSpan).mockReturnValue(undefined);
-      vi.mocked(getTraceData).mockReturnValue({});
+      vi.mocked(getActiveSpan).mockReturnValueOnce(undefined);
+      vi.mocked(getTraceData).mockReturnValueOnce({});
 
       expect(generateSentryServerTimingHeader()).toBeNull();
     });
@@ -60,8 +64,8 @@ describe('serverTimingTracePropagation', () => {
     });
 
     it('falls back to getTraceData without active span', () => {
-      vi.mocked(getActiveSpan).mockReturnValue(undefined);
-      vi.mocked(getTraceData).mockReturnValue({
+      vi.mocked(getActiveSpan).mockReturnValueOnce(undefined);
+      vi.mocked(getTraceData).mockReturnValueOnce({
         'sentry-trace': 'fallback-trace-id-1234567890123456-0',
         baggage: 'sentry-fallback=true',
       });
@@ -73,7 +77,7 @@ describe('serverTimingTracePropagation', () => {
     });
 
     it('generates header in Cloudflare environment when isNodeEnv is false', () => {
-      vi.mocked(isNodeEnv).mockReturnValue(false);
+      vi.mocked(isNodeEnv).mockReturnValueOnce(false);
 
       const originalNavigator = globalThis.navigator;
       Object.defineProperty(globalThis, 'navigator', {