adjust tests

Author: Lms24

dev-packages/e2e-tests/test-applications/create-remix-app-express/tests/server-transactions.test.ts

@@ -14,6 +14,7 @@ test('Sends parameterized transaction name to Sentry', async ({ page }) => {
 
   expect(transaction).toBeDefined();
   expect(transaction.transaction).toBe('GET user/:id');
+  expect(transaction.contexts?.trace?.data?.['http.route']).toBe('user/:id');
 });
 
 test('Sends form data with action span', async ({ page }) => {
@@ -271,6 +272,7 @@ test('Sends two linked transactions (server & client) to Sentry', async ({ page
   const pageLoadParentSpanId = pageloadTransaction.contexts?.trace?.parent_span_id;
 
   expect(httpServerTransaction.transaction).toBe('GET http://localhost:3030/');
+  expect(httpServerTransaction.contexts?.trace?.data?.['http.route']).toBeUndefined();
   expect(pageloadTransaction.transaction).toBe('/');
 
   expect(httpServerTraceId).toBeDefined();

packages/elysia/test/withElysia.test.ts

@@ -1,3 +1,4 @@
+import { HTTP_ROUTE } from '@sentry/conventions/attributes';
 import type { ErrorContext } from 'elysia';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -32,6 +33,12 @@ const mockGetIsolationScope = vi.fn(() => ({
 const mockGetClient = vi.fn(() => ({
   on: vi.fn(),
 }));
+const mockRootSpan = {
+  setAttributes: vi.fn(),
+  updateName: vi.fn(),
+};
+const mockGetActiveSpan = vi.fn();
+const mockGetRootSpan = vi.fn(() => mockRootSpan);
 const mockGetTraceData = vi.fn(() => ({
   'sentry-trace': 'abc123-def456-1',
   baggage: 'sentry-environment=test,sentry-trace_id=abc123',
@@ -43,8 +50,10 @@ vi.mock('@sentry/core', async importActual => {
   return {
     ...actual,
     captureException: (...args: unknown[]) => mockCaptureException(...args),
+    getActiveSpan: () => mockGetActiveSpan(),
     getIsolationScope: () => mockGetIsolationScope(),
     getClient: () => mockGetClient(),
+    getRootSpan: () => mockGetRootSpan(),
     getTraceData: () => mockGetTraceData(),
   };
 });
@@ -88,6 +97,23 @@ describe('withElysia', () => {
       expect(headers['baggage']).toBe('sentry-environment=test,sentry-trace_id=abc123');
     });
 
+    it('sets the matched route on the root span', () => {
+      mockGetActiveSpan.mockReturnValueOnce(mockRootSpan);
+      // @ts-expect-error - mock app
+      withElysia(mockApp);
+
+      onAfterHandleHandler({
+        route: '/users/:id',
+        request: new Request('https://example.com/users/42', { method: 'GET' }),
+        set: { headers: {} },
+      });
+
+      expect(mockRootSpan.setAttributes).toHaveBeenCalledWith({
+        'sentry.source': 'route',
+        [HTTP_ROUTE]: '/users/:id',
+      });
+    });
+
     it('does not set headers when trace data is empty', () => {
       mockGetTraceData.mockReturnValueOnce({});
       // @ts-expect-error - mock app

packages/hono/test/shared/middlewareHandlers.test.ts

@@ -1,4 +1,5 @@
 import * as SentryCore from '@sentry/core';
+import { HTTP_ROUTE } from '@sentry/conventions/attributes';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { requestHandler, responseHandler } from '../../src/shared/middlewareHandlers';
 
@@ -245,6 +246,18 @@ describe('responseHandler', () => {
 
       expect(mockSetTransactionName).toHaveBeenCalledWith('GET /test');
     });
+
+    it('sets http.route on the root span', () => {
+      getActiveSpanMock.mockReturnValue(mockRootSpan);
+
+      // oxlint-disable-next-line typescript/no-explicit-any
+      requestHandler(createMockContext(200) as any);
+
+      expect(mockRootSpan.setAttributes).toHaveBeenCalledWith({
+        'sentry.source': 'route',
+        [HTTP_ROUTE]: 'GET /test',
+      });
+    });
   });
 });
 

packages/nextjs/test/config/withSentry.test.ts

@@ -1,5 +1,5 @@
 import * as SentryCore from '@sentry/core';
-import { URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
+import { HTTP_ROUTE, URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -55,6 +55,7 @@ describe('withSentry', () => {
             [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.nextjs',
             [URL_FULL]: 'https://dogs.are.great/api/dogs?good=true',
             [URL_PATH]: '/api/dogs',
+            [HTTP_ROUTE]: '/my-parameterized-route',
           },
         },
         expect.any(Function),

packages/nextjs/test/edge/withSentryAPI.test.ts

@@ -1,4 +1,7 @@
-import { afterAll, afterEach, describe, it, vi } from 'vitest';
+import * as SentryCore from '@sentry/core';
+import { HTTP_ROUTE, URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
 import { wrapApiHandlerWithSentry } from '../../src/edge';
 
 const origRequest = global.Request;
@@ -30,7 +33,7 @@ afterAll(() => {
 });
 
 afterEach(() => {
-  vi.clearAllMocks();
+  vi.restoreAllMocks();
 });
 
 describe('wrapApiHandlerWithSentry', () => {
@@ -41,4 +44,28 @@ describe('wrapApiHandlerWithSentry', () => {
 
     await wrappedFunction();
   });
+
+  it('adds normalized request URL and route attributes to the active root span', async () => {
+    const rootSpan = {
+      updateName: vi.fn(),
+      setAttributes: vi.fn(),
+    };
+    vi.spyOn(SentryCore, 'getActiveSpan').mockReturnValueOnce({} as any);
+    vi.spyOn(SentryCore, 'getRootSpan').mockReturnValueOnce(rootSpan as any);
+    vi.spyOn(SentryCore, 'spanToJSON').mockReturnValueOnce({ data: {} } as any);
+    const origFunction = vi.fn(() => new Response());
+    const parameterizedRoute = '/user/[userId]/post/[postId]';
+    const wrappedFunction = wrapApiHandlerWithSentry(origFunction, parameterizedRoute);
+
+    await wrappedFunction(new Request('https://dogs.are.great/user/123/post/456?good=true'));
+
+    expect(rootSpan.updateName).toHaveBeenCalledWith(`POST ${parameterizedRoute}`);
+    expect(rootSpan.setAttributes).toHaveBeenCalledWith({
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
+      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+      [URL_FULL]: 'https://dogs.are.great/user/123/post/456?good=true',
+      [URL_PATH]: '/user/123/post/456',
+      [HTTP_ROUTE]: parameterizedRoute,
+    });
+  });
 });

packages/nextjs/test/server/enhanceHandleRequestRootSpan.test.ts

@@ -1,3 +1,4 @@
+import { HTTP_ROUTE } from '@sentry/conventions/attributes';
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
 import { describe, expect, it } from 'vitest';
 import { ATTR_NEXT_ROUTE, ATTR_NEXT_SPAN_NAME, ATTR_NEXT_SPAN_TYPE } from '../../src/common/nextSpanAttributes';
@@ -105,6 +106,7 @@ describe('enhanceHandleRequestRootSpan', () => {
     enhanceHandleRequestRootSpan(span);
 
     expect(getName()).toBe('GET /posts/[slug]');
+    expect(span.attributes[HTTP_ROUTE]).toBe('/posts/[slug]');
   });
 
   it('does not apply the backfill for the special GET /_app transaction', () => {

packages/sveltekit/test/server-common/handle.test.ts

@@ -1,4 +1,5 @@
 import type { EventEnvelopeHeaders, Span } from '@sentry/core';
+import { HTTP_ROUTE } from '@sentry/conventions/attributes';
 import {
   getRootSpan,
   getSpanDescendants,
@@ -143,6 +144,7 @@ describe('sentryHandle', () => {
       expect(spanToJSON(_span!).op).toEqual('http.server');
       expect(spanToJSON(_span!).status).toEqual(isError ? 'internal_error' : 'ok');
       expect(spanToJSON(_span!).data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]).toEqual('route');
+      expect(spanToJSON(_span!).data?.[HTTP_ROUTE]).toEqual('/users/[id]');
 
       expect(spanToJSON(_span!).timestamp).toBeDefined();
 
@@ -151,6 +153,7 @@ describe('sentryHandle', () => {
     });
 
     it("doesn't start a span if sveltekit tracing is enabled", async () => {
+      const kitRootSpan = SentryCore.startInactiveSpan({ name: 'sveltekit.handle.root' });
       let _span: Span | undefined = undefined;
       client.on('spanEnd', span => {
         if (span === getRootSpan(span)) {
@@ -160,14 +163,16 @@ describe('sentryHandle', () => {
 
       try {
         await sentryHandle()({
-          event: mockEvent({ tracing: { enabled: true } }),
+          event: mockEvent({ tracing: { enabled: true, root: kitRootSpan } }),
           resolve: resolve(type, isError),
         });
       } catch {
         //
       }
 
       expect(_span).toBeUndefined();
+      expect(spanToJSON(kitRootSpan).data?.[HTTP_ROUTE]).toEqual('/users/[id]');
+      kitRootSpan.end();
     });
 
     it('starts a child span for nested server calls (i.e. if there is an active span)', async () => {