feat(remix): Add Server-Timing header trace propagation

Author: onurtemizkan

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;
 }

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');
+});

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'],
+};

dev-packages/e2e-tests/test-applications/remix-server-timing/.gitignore

@@ -0,0 +1,3 @@
+node_modules
+build
+.env

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

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>,
+  );
+});

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);
+  });
+}

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);

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>
+  );
+}

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');
+};