test(e2e): Address review on the node-flue app

- Drop the explicit `dataloaderIntegration()`; it is in `getTracingIntegrations()`
  now, so Node registers it by default when spans are enabled.
- Always run under orchestrion rather than keeping it as a variant, since that
  is how the SDK is meant to be set up. Removes the `*:orchestrion` scripts, the
  `USE_ORCHESTRION` plumbing and the `test.fail()` branch in the dataloader test,
  which now simply asserts the span lands under `execute_tool`.
- Drop the node-eve reference from `vite.config.ts`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: RulaKhaled

dev-packages/e2e-tests/test-applications/node-flue/package.json

@@ -4,17 +4,13 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "vite dev --port 3030",
+    "dev": "NODE_OPTIONS='--import=@sentry/node/import' vite dev --port 3030",
     "build": "vite build",
-    "start": "PORT=3030 node dist/server.mjs",
-    "dev:orchestrion": "NODE_OPTIONS='--import=@sentry/node/import' pnpm dev",
-    "start:orchestrion": "NODE_OPTIONS='--import=@sentry/node/import' pnpm start",
+    "start": "NODE_OPTIONS='--import=@sentry/node/import' PORT=3030 node dist/server.mjs",
     "clean": "npx rimraf node_modules dist pnpm-lock.yaml",
     "test:build": "pnpm install && pnpm build",
-    "test:build-orchestrion": "USE_ORCHESTRION=1 pnpm test:build",
     "test:build-latest": "pnpm install && pnpm add @flue/runtime@latest @flue/vite@latest @flue/cli@latest && pnpm build",
     "test:assert": "pnpm test:prod && pnpm test:dev",
-    "test:assert-orchestrion": "USE_ORCHESTRION=1 pnpm test:assert",
     "test:prod": "OPENROUTER_API_KEY=$E2E_OPENROUTER_API_KEY TEST_ENV=production playwright test",
     "test:dev": "OPENROUTER_API_KEY=$E2E_OPENROUTER_API_KEY TEST_ENV=development playwright test"
   },
@@ -48,11 +44,6 @@
       {
         "build-command": "pnpm test:build-latest",
         "label": "node-flue (latest)"
-      },
-      {
-        "build-command": "pnpm test:build-orchestrion",
-        "assert-command": "pnpm test:assert-orchestrion",
-        "label": "node-flue (orchestrion)"
       }
     ]
   }

dev-packages/e2e-tests/test-applications/node-flue/playwright.config.mjs

@@ -1,22 +1,15 @@
 import { getPlaywrightConfig } from '@sentry-internal/test-utils';
 
 const testEnv = process.env.TEST_ENV;
-const useOrchestrion = process.env.USE_ORCHESTRION === '1';
 
 if (!testEnv) {
   throw new Error('No test env defined');
 }
 
-let startCommand = testEnv === 'development' ? 'pnpm dev' : 'pnpm start';
-
-if (useOrchestrion) {
-  startCommand = `${startCommand}:orchestrion`;
-}
-
 const config = getPlaywrightConfig(
-  { startCommand },
-  // Each agent turn is a real OpenRouter tool-calling round trip (two model calls) followed by a
-  // span flush, which does not fit the default 30s timeout when the provider is slow.
+  { startCommand: testEnv === 'development' ? 'pnpm dev' : 'pnpm start' },
+  // Each test drives a real OpenRouter tool-calling turn and then waits for the spans to flush,
+  // which does not fit the default 30s timeout when the provider is slow.
   { timeout: 90_000 },
 );
 

dev-packages/e2e-tests/test-applications/node-flue/sentry-init.ts

@@ -1,17 +1,13 @@
 import { instrument } from '@flue/runtime';
 import * as Sentry from '@sentry/node';
 
-// Imported for its side effects as the first line of `src/app.ts`, which is how a Flue app is
-// expected to set Sentry up: there is no framework-owned instrumentation hook to auto-discover.
+// Imported for its side effects as the first line of `src/app.ts`, which is how a Flue app sets
+// Sentry up: there is no framework-owned instrumentation hook to auto-discover.
 Sentry.init({
   environment: 'qa',
   dsn: process.env.E2E_TEST_DSN,
   tunnel: 'http://localhost:3031/', // proxy server
   tracesSampleRate: 1.0,
-  // Not a default integration. It only produces spans in the "orchestrion" test variant, where the
-  // server starts with `NODE_OPTIONS=--import=@sentry/node/import` so the module transform is
-  // registered before `dataloader` is loaded.
-  integrations: [Sentry.dataloaderIntegration()],
 });
 
 instrument(Sentry.createFlueInstrumentation());

dev-packages/e2e-tests/test-applications/node-flue/tests/dataloader.test.ts

@@ -3,44 +3,29 @@ import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
 import { runAgentTurn } from './utils';
 
 const APP = 'node-flue';
-const useOrchestrion = process.env.USE_ORCHESTRION === '1';
 
 const isDataloaderSpan = (span: { attributes?: Record<string, { value?: unknown }> }): boolean =>
   span.attributes?.['sentry.origin']?.value === 'auto.db.dataloader';
 
 /**
- * `dataloaderIntegration` relies on orchestrion, a module transform, so it only emits spans when the
- * server starts with `NODE_OPTIONS=--import=@sentry/node/import` (the `node-flue (orchestrion)`
- * variant). The integration installs and subscribes either way, so the absence of a span is the only
- * thing that distinguishes the two — hence `test.fail(!useOrchestrion)`.
- *
- * Flue needs no build configuration for this: a Flue node build leaves dependencies as bare
- * specifiers, so `dataloader` stays a real module the transform can hook. If Flue ever switches to
- * a bundled server output, this test is what catches it.
+ * `dataloader` is instrumented through orchestrion, a module transform, so it only produces spans
+ * with the loader registered at process start. A Flue node build needs no externals config for
+ * that: dependencies stay bare specifiers, so `dataloader` is still a real module to hook. If Flue
+ * ever switches to a bundled server output, this is what catches it.
  *
  * The loader is called from inside a tool so its span lands in the agent's trace, beside the AI
  * spans, rather than in a trace of its own.
  */
 test('captures orchestrion-instrumented dataloader spans in the same trace as the AI spans', async ({ baseURL }) => {
-  test.fail(!useOrchestrion, 'orchestrion module instrumentation needs NODE_OPTIONS=--import=@sentry/node/import');
-
-  // With orchestrion, wait for the dataloader span itself. Without it that span never arrives, so
-  // anchor on the always-present tool span and let the assertion below fail fast rather than time
-  // the test out.
-  const spansPromise = collectStreamedSpans(APP, spansOfTrace =>
-    useOrchestrion
-      ? spansOfTrace.some(isDataloaderSpan)
-      : spansOfTrace.some(span => getSpanOp(span) === 'gen_ai.execute_tool'),
-  );
+  const spansPromise = collectStreamedSpans(APP, spansOfTrace => spansOfTrace.some(isDataloaderSpan));
 
   await runAgentTurn(baseURL!, 'dataloader-conversation', 'Please call count_items to count the items.');
 
   const spans = await spansPromise;
   const executeTool = spans.find(span => span.attributes?.['gen_ai.tool.name']?.value === 'count_items');
   const dataloaderSpan = spans.find(isDataloaderSpan);
 
-  expect(dataloaderSpan?.attributes?.['sentry.origin']?.value).toBe('auto.db.dataloader');
-  // Same trace as the AI spans, and underneath the tool that triggered it.
+  expect(getSpanOp(dataloaderSpan!)).toBe('cache.get');
   expect(dataloaderSpan?.trace_id).toBe(executeTool?.trace_id);
   expect(dataloaderSpan?.parent_span_id).toBe(executeTool?.span_id);
 });

dev-packages/e2e-tests/test-applications/node-flue/vite.config.ts

@@ -1,9 +1,9 @@
 import { flue } from '@flue/vite';
 import { defineConfig } from 'vite';
 
-// Unmodified from what `flue init` scaffolds. In particular there is no externals config: a Flue
-// node build leaves dependencies as bare specifiers, so orchestrion's module transform still sees
-// them as real modules. (eve needs `externalDependencies` because it emits a bundled server.)
+// Unmodified from what `flue init` scaffolds. No externals config is needed: a Flue node build
+// already leaves dependencies as bare specifiers, so orchestrion's module transform still sees them
+// as real modules.
 export default defineConfig({
   plugins: [flue()],
 });