Revert "feat(node): Name Mastra server routes from their route pattern"

This reverts commit 06e931c.

Author: mydea

CHANGELOG.md

@@ -16,7 +16,6 @@ Work in this release was contributed by @psh4607, @thijsw, @trinitiwowka, @nehap
   - `DenoMysql` => `Mysql`
   - `DenoPostgres` => `Postgres`
 - feat(node): Add first-party Mastra integration ([#23823](https://github.com/getsentry/sentry-javascript/pull/23823)). Enabled by default; disable with `defaultIntegrations: integrations => integrations.filter(i => i.name !== 'Mastra')`.
-- feat(node): Name Mastra server routes from their route pattern. The Mastra integration now names incoming requests' `http.server` span after the matched Hono route (e.g. `POST /api/agents/:agentId/generate`, `GET /echo/:id`) with `http.route` set and name source `route`, instead of the raw URL — for both built-in API routes and custom `registerApiRoute`s. This keeps route transactions low-cardinality. Disable with `mastraIntegration({ instrumentServerRoutes: false })`.
 - feat(node): Enable the `dataloader` and `knex` integrations by default. Both were previously opt-in — `dataloader` was removed from the defaults in v8 due to an upstream OpenTelemetry bug that has since been fixed, and `knex` was never enabled by default. You no longer need to add `dataloaderIntegration()` or `knexIntegration()` manually. Disable either with `defaultIntegrations: integrations => integrations.filter(i => i.name !== 'Dataloader' /* or 'Knex' */)`.
 - **feat(browser): Add `bfcacheMetricsIntegration` to track back/forward cache health**
 

dev-packages/e2e-tests/test-applications/node-mastra/src/mastra/index.ts

@@ -7,32 +7,22 @@ import { WEATHER_AGENT, weatherAgent } from './agents/weather-agent.js';
 // endpoint (see tests/utils.ts). `dataloader` (orchestrion-instrumented) is now
 // exercised through the agent's `count_items` tool (see src/mastra/tools/count-items.ts).
 
-// A plain (static) custom route: verifies requests to app-registered routes are wrapped in an
-// `http.server` span. With the Mastra integration's route naming, the span is named `GET /manual-route`
-// (name source `route`, `http.route` set) — see tests/manual-route.test.ts.
+// A plain custom route to verify that requests to app-registered routes are
+// wrapped in an `http.server` span with the correct route attributes (method,
+// route pattern, status code) — independent of the agent/AI instrumentation.
 const manualRoute = registerApiRoute('/manual-route', {
   method: 'GET',
   handler(c) {
     return c.json({ ok: true });
   },
 });
 
-// A parametrized custom route: verifies the integration names the `http.server` span from the matched
-// route *pattern* (`GET /echo/:id`), not the raw URL — so `/echo/42` and `/echo/99` collapse to one
-// low-cardinality transaction with `http.route: /echo/:id`.
-const echoRoute = registerApiRoute('/echo/:id', {
-  method: 'GET',
-  handler(c) {
-    return c.json({ id: c.req.param('id') });
-  },
-});
-
 export const mastra = new Mastra({
   agents: { [WEATHER_AGENT]: weatherAgent },
   storage: new LibSQLStore({ id: 'mastra-storage', url: ':memory:' }),
   server: {
     port: 4111,
-    apiRoutes: [manualRoute, echoRoute],
+    apiRoutes: [manualRoute],
   },
 });
 
@@ -42,4 +32,5 @@ export const mastra = new Mastra({
  *
   1. Bubbled-up tool errors aren't captured as issues — only reflected on the span (status + error.type); the exporter leaves captureException to the app.
   2. Mastra runs tools with inactive spans, so the `count_items` tool must open its own active span (startSpan) for dataloader's `cache.get` span to emit.
+  3. parametrized routes for mastra?
   */

dev-packages/e2e-tests/test-applications/node-mastra/tests/manual-route.test.ts

@@ -5,54 +5,35 @@ const APP = 'node-mastra';
 
 const attrValue = (span: SerializedStreamedSpan, key: string): unknown => span.attributes?.[key]?.value;
 
-// Custom routes registered on the Mastra (Hono) server — see `src/mastra/index.ts`. These verify the
-// Mastra integration's zero-config route naming: incoming requests get an `http.server` span named
-// from the matched route *pattern* (name source `route`, `http.route` set), for both static and
-// parametrized routes, with no app-level middleware. Runs in both the prod (`mastra start`) and dev
-// (`mastra dev`) variants.
-const serverSpanForUrl =
-  (urlIncludes: string) =>
-  (span: SerializedStreamedSpan): boolean =>
-    getSpanOp(span) === 'http.server' && String(attrValue(span, 'url.full') ?? '').includes(urlIncludes);
-
-test('names a static custom route from its route pattern', async ({ baseURL }) => {
-  const spansPromise = collectStreamedSpans(APP, spansOfTrace => spansOfTrace.some(serverSpanForUrl('/manual-route')));
+// A plain custom route registered on the Mastra (Hono) server — see the
+// `/manual-route` handler in src/mastra/index.ts. This verifies that ordinary HTTP
+// requests to app-registered routes are wrapped in an `http.server` span with the
+// expected attributes, independent of the agent / AI instrumentation. Runs in both
+// the prod (`mastra start`) and dev (`mastra dev`) variants.
+const isManualRouteServerSpan = (span: SerializedStreamedSpan): boolean =>
+  getSpanOp(span) === 'http.server' && String(attrValue(span, 'url.full') ?? '').includes('/manual-route');
+
+test('wraps a custom Mastra route in an http.server span with correct attributes', async ({ baseURL }) => {
+  const spansPromise = collectStreamedSpans(APP, spansOfTrace => spansOfTrace.some(isManualRouteServerSpan));
 
   const res = await fetch(`${baseURL}/manual-route`, { method: 'GET' });
   expect(res.status).toBe(200);
   await res.json();
 
-  const serverSpan = (await spansPromise).find(serverSpanForUrl('/manual-route'));
+  const spans = await spansPromise;
+  const serverSpan = spans.find(isManualRouteServerSpan);
 
   expect(serverSpan).toBeDefined();
   expect(getSpanOp(serverSpan!)).toBe('http.server');
+  expect(serverSpan!.name).toBe('GET');
   expect(attrValue(serverSpan!, 'http.request.method')).toBe('GET');
   expect(attrValue(serverSpan!, 'http.response.status_code')).toBe(200);
-
-  // The Mastra integration upgrades the span from the raw URL to the route pattern: for a static
-  // route these are identical, but the name source is `route` and `http.route` is set.
-  expect(serverSpan!.name).toBe('GET /manual-route');
-  expect(attrValue(serverSpan!, 'http.route')).toBe('/manual-route');
-  expect(attrValue(serverSpan!, 'sentry.segment.name.source')).toBe('route');
-});
-
-test('names a parametrized custom route from its route pattern (low cardinality)', async ({ baseURL }) => {
-  // Two different ids must collapse to the same `/echo/:id` transaction.
-  for (const id of ['42', '99']) {
-    const spansPromise = collectStreamedSpans(APP, spansOfTrace =>
-      spansOfTrace.some(span => serverSpanForUrl(`/echo/${id}`)(span)),
-    );
-
-    const res = await fetch(`${baseURL}/echo/${id}`, { method: 'GET' });
-    expect(res.status).toBe(200);
-    await res.json();
-
-    const serverSpan = (await spansPromise).find(serverSpanForUrl(`/echo/${id}`));
-
-    expect(serverSpan).toBeDefined();
-    // Name and route are the pattern, not the concrete URL (`/echo/42`).
-    expect(serverSpan!.name).toBe('GET /echo/:id');
-    expect(attrValue(serverSpan!, 'http.route')).toBe('/echo/:id');
-    expect(attrValue(serverSpan!, 'sentry.segment.name.source')).toBe('route');
-  }
+  expect(String(attrValue(serverSpan!, 'url.full') ?? '')).toContain('/manual-route');
+
+  // Codifies current behavior: the transaction name is derived from the URL path,
+  // not a route pattern. Mastra serves custom routes through Hono, which Sentry
+  // does not route-instrument the way it does Express — so there is no `http.route`
+  // attribute and the name source is `url` (an Express route would give `route`).
+  expect(attrValue(serverSpan!, 'sentry.segment.name.source')).toBe('url');
+  expect(attrValue(serverSpan!, 'http.route')).toBeUndefined();
 });

packages/server-utils/src/integrations/mastra-route-naming.ts

@@ -17,22 +17,13 @@ import { CHANNELS } from '../orchestrion/channels';
 import { mastraModuleNames } from '../orchestrion/config/mastra';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
 import { safeChannelCallback } from '../tracing-channel';
-import { injectMastraRouteNamingMiddleware } from './mastra-route-naming';
 
 export interface MastraOptions extends MastraExporterOptions {
   /**
    * Construct a Mastra observability pipeline when the app has not configured one. Defaults to
    * `true`. Uses an `@mastra/observability` the app already has; the SDK never installs it.
    */
   bootstrapObservability?: boolean;
-
-  /**
-   * Give the incoming `http.server` span the matched route pattern (e.g.
-   * `POST /api/agents/:agentId/generate`) with `http.route` and name source `route`, instead of the
-   * raw URL. Works for Mastra's built-in API routes and custom `registerApiRoute`s. Defaults to
-   * `true`. Set `false` to leave route naming to the app.
-   */
-  instrumentServerRoutes?: boolean;
 }
 
 interface MastraObservabilityInstance {
@@ -69,20 +60,7 @@ const _mastraIntegration = ((options: MastraOptions = {}) => {
 }) satisfies IntegrationFn;
 
 function instrumentMastra(options: MastraOptions): void {
-  const channel = diagnosticsChannel.tracingChannel<ConstructorChannelContext>(CHANNELS.MASTRA_CONSTRUCTOR);
-
-  // `start` fires before the constructor body reads `config.server`, so mutating the config here adds
-  // our route-naming middleware to the Hono server without needing a reference to the (internal) app.
-  if (options.instrumentServerRoutes !== false) {
-    channel.start.subscribe(message => {
-      safeChannelCallback(() => {
-        const { arguments: constructorArgs } = message as ConstructorChannelContext;
-        injectMastraRouteNamingMiddleware(constructorArgs?.[0]);
-      });
-    });
-  }
-
-  channel.end.subscribe(message => {
+  diagnosticsChannel.tracingChannel<ConstructorChannelContext>(CHANNELS.MASTRA_CONSTRUCTOR).end.subscribe(message => {
     safeChannelCallback(() => {
       const { self } = message as ConstructorChannelContext;
       attachExporter(self, options);
@@ -102,11 +80,7 @@ function attachExporter(instance: unknown, options: MastraOptions): void {
     return;
   }
 
-  const {
-    bootstrapObservability: _bootstrapObservability,
-    instrumentServerRoutes: _instrumentServerRoutes,
-    ...exporterOptions
-  } = options;
+  const { bootstrapObservability: _bootstrapObservability, ...exporterOptions } = options;
   const exporter = new SentryMastraExporter(exporterOptions);
 
   const defaultInstance = mastra.observability?.getDefaultInstance?.();