feat(remix): Add orchestrion-based remix instrumentation

dev-packages/e2e-tests/test-applications/remix-orchestrion/docker-compose.yml → dev-packages/e2e-tests/test-applications/create-remix-app-v2/docker-compose.yml

@@ -2,7 +2,7 @@ services:
  db:
  image: mysql:8.0
  restart: always
- container_name: e2e-tests-remix-orchestrion-mysql
+ container_name: e2e-tests-create-remix-app-v2-mysql
  # The `mysql` 2.x driver doesn't speak MySQL 8's default
  # `caching_sha2_password` auth, so force the legacy plugin.
  command: ['--default-authentication-plugin=mysql_native_password']
@@ -20,7 +20,7 @@ services:
  redis:
  image: redis:7
  restart: always
- container_name: e2e-tests-remix-orchestrion-redis
+ container_name: e2e-tests-create-remix-app-v2-redis
  ports:
  - '6379:6379'
  healthcheck:

dev-packages/e2e-tests/test-applications/remix-orchestrion/global-setup.mjs → dev-packages/e2e-tests/test-applications/create-remix-app-v2/global-setup.mjs

@@ -13,7 +13,7 @@ export default async function globalSetup() {
  // recognize a leftover container from a previous (e.g. interrupted) run as
  // part of the same project - but the container names are fixed, so the daemon
  // still refuses to create new ones. Force-remove any stale leftovers first.
- for (const container of ['e2e-tests-remix-orchestrion-mysql', 'e2e-tests-remix-orchestrion-redis']) {
+ for (const container of ['e2e-tests-create-remix-app-v2-mysql', 'e2e-tests-create-remix-app-v2-redis']) {
  try {
  execSync(`docker rm -f ${container}`, { stdio: 'ignore' });
  } catch {

dev-packages/e2e-tests/test-applications/create-remix-app-v2/instrument.server.cjs

@@ -1,5 +1,15 @@
 const Sentry = require('@sentry/remix');
 
+const injectOrchestrion = process.env.INJECT_ORCHESTRION === 'true';
+
+if (injectOrchestrion) {
+ // Opt into diagnostics-channel-based auto-instrumentation. This registers the
+ // channel subscribers (e.g. for mysql and ioredis) that turn the
+ // diagnostics-channel events - injected at build time by the orchestrion Vite
+ // plugin (see vite.config.ts) - into Sentry spans. Must run before Sentry.init().
+ Sentry.experimentalUseDiagnosticsChannelInjection();
+}
+
 Sentry.init({
  tracesSampleRate: 1.0, // Capture 100% of the transactions, reduce in production!
  environment: 'qa', // dynamic sampling bias to keep transactions

dev-packages/e2e-tests/test-applications/create-remix-app-v2/package.json

@@ -1,22 +1,28 @@
 {
  "private": true,
  "sideEffects": false,
+ "type": "module",
  "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"
+ "test:assert": "pnpm playwright test",
+ "test:build:orchestrion": "INJECT_ORCHESTRION=true pnpm test:build",
+ "test:assert:orchestrion": "INJECT_ORCHESTRION=true pnpm test:assert"
  },
  "dependencies": {
  "@sentry/remix": "file:../../packed/sentry-remix-packed.tgz",
+ "@sentry/server-utils": "file:../../packed/sentry-server-utils-packed.tgz",
  "@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",
+ "ioredis": "5.10.1",
+ "mysql": "^2.18.1",
  "react": "^18.2.0",
  "react-dom": "^18.2.0"
  },
@@ -25,6 +31,7 @@
  "@sentry-internal/test-utils": "link:../../../test-utils",
  "@remix-run/dev": "2.17.4",
  "@remix-run/eslint-config": "2.17.4",
+ "@types/mysql": "^2.15.26",
  "@types/react": "^18.2.64",
  "@types/react-dom": "^18.2.34",
  "@types/prop-types": "15.7.7",
@@ -36,6 +43,15 @@
  "resolutions": {
  "@types/react": "18.2.22"
  },
+ "sentryTest": {
+ "variants": [
+ {
+ "build-command": "pnpm test:build:orchestrion",
+ "assert-command": "pnpm test:assert:orchestrion",
+ "label": "create-remix-app-v2 (orchestrion)"
+ }
+ ]
+ },
  "volta": {
  "extends": "../../package.json"
  }

dev-packages/e2e-tests/test-applications/create-remix-app-v2/playwright.config.mjs

@@ -1,7 +1,20 @@
 import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+import { fileURLToPath } from 'url';
 
-const config = getPlaywrightConfig({
- startCommand: `pnpm start`,
-});
+const injectOrchestrion = process.env.INJECT_ORCHESTRION === 'true';
+
+const config = getPlaywrightConfig(
+ {
+ startCommand: `pnpm start`,
+ },
+ // The orchestrion variant exercises real MySQL/Redis. Boot them before the tests run,
+ // outside the webServer startup-timeout window. In the default variant no DB is needed.
+ injectOrchestrion
+ ? {
+ globalSetup: fileURLToPath(new URL('./global-setup.mjs', import.meta.url)),
+ globalTeardown: fileURLToPath(new URL('./global-teardown.mjs', import.meta.url)),
+ }
+ : {},
+);
 
 export default config;

dev-packages/e2e-tests/test-applications/create-remix-app-v2/tests/build-injection.test.ts

@@ -0,0 +1,50 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { expect, test } from '@playwright/test';
+
+// The `db.test.ts` runtime assertions prove orchestrion spans appear, but spans alone
+// don't prove they came from the BUILD-time transform: if the Vite plugin silently
+// failed to load, the deps would stay external and the runtime `--require` hook would
+// inject the channels at runtime instead - the span tests would still pass. These
+// assertions inspect the built server bundle directly so a broken plugin can't hide
+// behind that runtime fallback. Only relevant in the orchestrion variant.
+test.describe('orchestrion build-time injection', () => {
+ test.skip(process.env.INJECT_ORCHESTRION !== 'true', 'Only runs in the orchestrion variant');
+
+ const serverBundle = readFileSync(path.join(process.cwd(), 'build/server/index.js'), 'utf8');
+
+ test('force-bundles the instrumented deps instead of externalizing them', () => {
+ // The plugin adds mysql/ioredis to `ssr.noExternal` so the transform sees their
+ // source. Without it they'd be left as bare imports or `require(...)` calls resolved
+ // from node_modules at runtime - untouched, with no channels injected.
+ expect(serverBundle).not.toMatch(/(from\s*["']mysql["']|require\(["']mysql["']\))/);
+ expect(serverBundle).not.toMatch(/(from\s*["']ioredis["']|require\(["']ioredis["']\))/);
+ });
+
+ test('injects the diagnostics-channel publishers into the bundled deps', () => {
+ // The transform wraps each instrumented function with a `tracingChannel("<name>")`
+ // publisher whose channel name is a string literal. The subscriber side passes the
+ // channel name as a variable, so a literal-arg match is unique to the injected
+ // publisher and proves the build-time transform ran.
+ expect(serverBundle).toMatch(/tracingChannel(\$?\d)?\(["']orchestrion:mysql:query["']\)/);
+ expect(serverBundle).toMatch(/tracingChannel(\$?\d)?\(["']orchestrion:ioredis:command["']\)/);
+ expect(serverBundle).toMatch(/tracingChannel(\$?\d)?\(["']orchestrion:ioredis:connect["']\)/);
+ });
+
+ test('injects the diagnostics-channel publishers into @remix-run/server-runtime', () => {
+ // Remix's own instrumentation is orchestrion-based too: the transform force-bundles
+ // and injects channels into `@remix-run/server-runtime`
+ expect(serverBundle).toMatch(
+ /tracingChannel(\$?\d)?\(["']orchestrion:@remix-run\/server-runtime:requestHandler["']\)/,
+ );
+ expect(serverBundle).toMatch(
+ /tracingChannel(\$?\d)?\(["']orchestrion:@remix-run\/server-runtime:matchServerRoutes["']\)/,
+ );
+ expect(serverBundle).toMatch(
+ /tracingChannel(\$?\d)?\(["']orchestrion:@remix-run\/server-runtime:callRouteLoader["']\)/,
+ );
+ expect(serverBundle).toMatch(
+ /tracingChannel(\$?\d)?\(["']orchestrion:@remix-run\/server-runtime:callRouteAction["']\)/,
+ );
+ });
+});

dev-packages/e2e-tests/test-applications/create-remix-app-v2/tests/db.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+// These assertions only hold in the orchestrion variant (INJECT_ORCHESTRION=true), which
+// force-bundles + transforms mysql/ioredis and boots the databases via docker-compose.
+test.describe('orchestrion DB instrumentation', () => {
+ test.skip(process.env.INJECT_ORCHESTRION !== 'true', 'Only runs in the orchestrion variant');
+
+ test('Instruments ioredis automatically via orchestrion', async ({ baseURL }) => {
+ const transactionEventPromise = waitForTransaction('create-remix-app-v2', transactionEvent => {
+ return (
+ transactionEvent.contexts?.trace?.op === 'http.server' && !!transactionEvent.transaction?.includes('db-ioredis')
+ );
+ });
+
+ await fetch(`${baseURL}/db-ioredis`);
+
+ const transactionEvent = await transactionEventPromise;
+
+ const spans = transactionEvent.spans || [];
+
+ expect(spans).toContainEqual(
+ expect.objectContaining({
+ op: 'db',
+ origin: 'auto.db.orchestrion.redis',
+ description: 'set test-key [1 other arguments]',
+ status: 'ok',
+ data: expect.objectContaining({
+ 'db.system': 'redis',
+ 'db.statement': 'set test-key [1 other arguments]',
+ }),
+ }),
+ );
+ expect(spans).toContainEqual(
+ expect.objectContaining({
+ op: 'db',
+ origin: 'auto.db.orchestrion.redis',
+ description: 'get test-key',
+ status: 'ok',
+ data: expect.objectContaining({
+ 'db.system': 'redis',
+ 'db.statement': 'get test-key',
+ }),
+ }),
+ );
+ });
+
+ test('Instruments mysql automatically via orchestrion', async ({ baseURL }) => {
+ const transactionEventPromise = waitForTransaction('create-remix-app-v2', transactionEvent => {
+ return (
+ transactionEvent.contexts?.trace?.op === 'http.server' && !!transactionEvent.transaction?.includes('db-mysql')
+ );
+ });
+
+ await fetch(`${baseURL}/db-mysql`);
+
+ const transactionEvent = await transactionEventPromise;
+
+ const spans = transactionEvent.spans || [];
+
+ expect(spans).toContainEqual(
+ expect.objectContaining({
+ op: 'db',
+ origin: 'auto.db.orchestrion.mysql',
+ description: 'SELECT 1 + 1 AS solution',
+ status: 'ok',
+ data: expect.objectContaining({
+ 'db.system': 'mysql',
+ 'db.statement': 'SELECT 1 + 1 AS solution',
+ 'db.user': 'root',
+ 'db.connection_string': expect.any(String),
+ 'net.peer.name': expect.any(String),
+ 'net.peer.port': 3306,
+ }),
+ }),
+ );
+ expect(spans).toContainEqual(
+ expect.objectContaining({
+ op: 'db',
+ origin: 'auto.db.orchestrion.mysql',
+ description: 'SELECT NOW()',
+ status: 'ok',
+ data: expect.objectContaining({
+ 'db.system': 'mysql',
+ 'db.statement': 'SELECT NOW()',
+ 'db.user': 'root',
+ 'db.connection_string': expect.any(String),
+ 'net.peer.name': expect.any(String),
+ 'net.peer.port': 3306,
+ }),
+ }),
+ );
+ });
+});

dev-packages/e2e-tests/test-applications/create-remix-app-v2/vite.config.ts

@@ -1,15 +1,22 @@
 import { vitePlugin as remix } from '@remix-run/dev';
 import { sentryRemixVitePlugin } from '@sentry/remix';
+import { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/vite';
 import { defineConfig } from 'vite';
 import tsconfigPaths from 'vite-tsconfig-paths';
 
+const injectOrchestrion = process.env.INJECT_ORCHESTRION === 'true';
+
 export default defineConfig({
  plugins: [
  remix({
  ignoredRouteFiles: ['**/.*'],
- serverModuleFormat: 'cjs',
  }),
  sentryRemixVitePlugin(),
+ // In the orchestrion variant, run the orchestrion code transform over the SSR
+ // server bundle and force-bundle the instrumented deps (mysql, ioredis,
+ // @remix-run/server-runtime, …) so their diagnostics-channel calls are injected
+ // at build time.
+ ...(injectOrchestrion ? [sentryOrchestrionPlugin()] : []),
  tsconfigPaths(),
  ],
 });