middleware.test.ts

import { expect, test } from '@playwright/test';
import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
import { type SpanJSON } from '@sentry/core';
import { APP_NAME } from './constants';

const SCENARIOS = [
  {
    name: 'root app middleware',
    prefix: '/test-middleware',
  },
  {
    name: 'sub-app middleware (route group)',
    prefix: '/test-subapp-middleware',
  },
] as const;

for (const { name, prefix } of SCENARIOS) {
  test.describe(name, () => {
    test('creates a span for named middleware', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${prefix}/named`);
      });

      const response = await fetch(`${baseURL}${prefix}/named`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      expect(transaction.transaction).toBe(`GET ${prefix}/named`);

      const spans = transaction.spans || [];

      const middlewareSpan = spans.find(
        (span: { description?: string; op?: string }) =>
          span.op === 'middleware.hono' && span.description === 'middlewareA',
      );

      expect(middlewareSpan).toEqual(
        expect.objectContaining({
          description: 'middlewareA',
          op: 'middleware.hono',
          origin: 'auto.middleware.hono',
        }),
      );
      expect(middlewareSpan?.status).not.toBe('internal_error');

      // @ts-expect-error timestamp is defined
      const durationMs = (middlewareSpan?.timestamp - middlewareSpan?.start_timestamp) * 1000;
      expect(durationMs).toBeGreaterThanOrEqual(49);
    });

    test('creates a span for anonymous middleware', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${prefix}/anonymous`);
      });

      const response = await fetch(`${baseURL}${prefix}/anonymous`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      expect(transaction.transaction).toBe(`GET ${prefix}/anonymous`);

      const spans = transaction.spans || [];

      const anonymousSpan = spans.find(
        (span: { description?: string; op?: string }) =>
          span.op === 'middleware.hono' && span.description === '<anonymous>',
      );
      expect(anonymousSpan).toBeDefined();
      expect(anonymousSpan?.origin).toBe('auto.middleware.hono');
      expect(anonymousSpan?.status).not.toBe('internal_error');
    });

    test('multiple middleware are sibling spans under the same parent', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${prefix}/multi`);
      });

      const response = await fetch(`${baseURL}${prefix}/multi`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      expect(transaction.transaction).toBe(`GET ${prefix}/multi`);

      const spans = transaction.spans || [];

      const middlewareSpans = spans.sort((a, b) => (a.start_timestamp ?? 0) - (b.start_timestamp ?? 0));

      expect(middlewareSpans).toHaveLength(2);
      expect(middlewareSpans[0]?.description).toBe('middlewareA');
      expect(middlewareSpans[1]?.description).toBe('middlewareB');

      expect(middlewareSpans[0]?.parent_span_id).toBe(middlewareSpans[1]?.parent_span_id);

      // middlewareA has a 50ms delay, middlewareB has a 60ms delay
      // @ts-expect-error timestamp is defined
      const aDurationMs = (middlewareSpans[0]?.timestamp - middlewareSpans[0]?.start_timestamp) * 1000;
      // @ts-expect-error timestamp is defined
      const bDurationMs = (middlewareSpans[1]?.timestamp - middlewareSpans[1]?.start_timestamp) * 1000;
      expect(aDurationMs).toBeGreaterThanOrEqual(49);
      expect(bDurationMs).toBeGreaterThanOrEqual(59);
    });

    test('captures error thrown in middleware', async ({ baseURL }) => {
      const errorPromise = waitForError(APP_NAME, event => {
        return event.exception?.values?.[0]?.value === 'Middleware error';
      });

      const response = await fetch(`${baseURL}${prefix}/error`);
      expect(response.status).toBe(500);

      const errorEvent = await errorPromise;
      expect(errorEvent.exception?.values?.[0]?.value).toBe('Middleware error');
      expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual(
        expect.objectContaining({
          handled: false,
          type: 'auto.middleware.hono',
        }),
      );

      // The transaction name on the error event determines the culprit shown in Sentry.
      expect(errorEvent.transaction).toBe(`GET ${prefix}/error`);
    });

    test('sets error status on middleware span when middleware throws', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${prefix}/error`);
      });

      await fetch(`${baseURL}${prefix}/error`);

      const transaction = await transactionPromise;
      expect(transaction.transaction).toBe(`GET ${prefix}/error`);

      const spans = transaction.spans || [];

      const failingSpan = spans.find(
        (span: SpanJSON) => span.op === 'middleware.hono' && span.status === 'internal_error',
      );

      expect(failingSpan).toBeDefined();
      expect(failingSpan?.status).toBe('internal_error');
    });

    test('uses parameterized route in transaction name', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${prefix}/param/`);
      });

      const response = await fetch(`${baseURL}${prefix}/param/42`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      expect(transaction.transaction).toBe(`GET ${prefix}/param/:id`);

      const spans = transaction.spans || [];
      const middlewareSpan = spans.find(
        (span: { description?: string; op?: string }) =>
          span.op === 'middleware.hono' && span.description === 'middlewareA',
      );
      expect(middlewareSpan).toBeDefined();
    });

    test('includes request data on error events from middleware', async ({ baseURL }) => {
      const errorPromise = waitForError(APP_NAME, event => {
        return event.exception?.values?.[0]?.value === 'Middleware error' && !!event.request?.url?.includes(prefix);
      });

      await fetch(`${baseURL}${prefix}/error`);

      const errorEvent = await errorPromise;
      expect(errorEvent.request).toEqual(
        expect.objectContaining({
          method: 'GET',
          url: expect.stringContaining(`${prefix}/error`),
        }),
      );
    });
  });
}

test.describe('.all() handler in sub-app', () => {
  test('does not create middleware span for .all() route handler', async ({ baseURL }) => {
    const transactionPromise = waitForTransaction(APP_NAME, event => {
      return (
        event.contexts?.trace?.op === 'http.server' &&
        !!event.transaction?.includes('/test-subapp-middleware/all-handler')
      );
    });

    const response = await fetch(`${baseURL}/test-subapp-middleware/all-handler`);
    expect(response.status).toBe(200);

    const body = await response.json();
    expect(body).toEqual({ handler: 'all' });

    const transaction = await transactionPromise;
    expect(transaction.transaction).toBe('GET /test-subapp-middleware/all-handler');

    const spans = transaction.spans || [];

    // No middleware is called for this route, so there should be no spans.
    expect(spans).toEqual([]);
  });
});

const INLINE_PREFIX = '/test-inline-middleware';

const REGISTRATION_STYLES = [
  { name: 'direct method (.get())', path: '/direct' },
  { name: '.all()', path: '/all' },
  { name: '.on()', path: '/on' },
] as const;

const MIDDLEWARE_STYLES = [
  { name: 'inline', path: '' },
  { name: 'separately registered', path: '/separately' },
] as const;

test.describe('inline middleware spans (sub-app)', () => {
  for (const { name: regName, path: regPath } of REGISTRATION_STYLES) {
    for (const { name: mwName, path: mwPath } of MIDDLEWARE_STYLES) {
      test(`creates middleware span for ${mwName} middleware via ${regName}`, async ({ baseURL }) => {
        const fullPath = `${INLINE_PREFIX}${regPath}${mwPath}`;

        const transactionPromise = waitForTransaction(APP_NAME, event => {
          return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(fullPath);
        });

        const response = await fetch(`${baseURL}${fullPath}`);
        expect(response.status).toBe(200);

        const transaction = await transactionPromise;
        expect(transaction.transaction).toBe(`GET ${fullPath}`);

        const EXPECTED_DESCRIPTIONS: Record<string, Record<string, string>> = {
          '/direct': { '': 'inlineMiddleware', '/separately': 'inlineSeparateMiddleware' },
          '/all': { '': 'inlineMiddlewareAll', '/separately': 'inlineSeparateMiddlewareAll' },
          '/on': { '': 'inlineMiddlewareOn', '/separately': 'inlineSeparateMiddlewareOn' },
        };
        const expectedDescription = EXPECTED_DESCRIPTIONS[regPath]![mwPath]!;

        const inlineSpan = (transaction.spans || []).find(s => s.description === expectedDescription);
        expect(inlineSpan).toBeDefined();
        expect(inlineSpan?.op).toBe('middleware.hono');
        expect(inlineSpan?.origin).toBe('auto.middleware.hono');
        expect(inlineSpan?.status).not.toBe('internal_error');
      });
    }
  }
});

const MAIN_INLINE_PREFIX = '/test-main-inline';

const MAIN_INLINE_CASES = [
  { name: '.get()', path: '/get', method: 'GET', expectedMiddlewareName: 'mainInlineGet' },
  { name: '.post()', path: '/post', method: 'POST', expectedMiddlewareName: 'mainInlinePost' },
  { name: '.all()', path: '/all', method: 'GET', expectedMiddlewareName: 'mainInlineAll' },
] as const;

test.describe('inline middleware spans (main app)', () => {
  MAIN_INLINE_CASES.forEach(({ name, path, method, expectedMiddlewareName }) => {
    test(`creates middleware span for inline middleware via ${name}`, async ({ baseURL }) => {
      const fullPath = `${MAIN_INLINE_PREFIX}${path}`;

      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && event.transaction === `${method} ${fullPath}`;
      });

      const response = await fetch(`${baseURL}${fullPath}`, { method });
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      expect(transaction.transaction).toBe(`${method} ${fullPath}`);

      const spans = transaction.spans || [];
      const inlineSpan = spans.find(s => s.description === expectedMiddlewareName);

      expect(inlineSpan).toBeDefined();
      expect(inlineSpan?.op).toBe('middleware.hono');
      expect(inlineSpan?.origin).toBe('auto.middleware.hono');
      expect(inlineSpan?.status).not.toBe('internal_error');

      const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
      expect(middlewareSpans).toHaveLength(1);
    });
  });

  test('creates spans for both .use() middleware and inline middleware via .get()', async ({ baseURL }) => {
    const fullPath = `${MAIN_INLINE_PREFIX}/combined/resource`;

    const transactionPromise = waitForTransaction(APP_NAME, event => {
      return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${fullPath}`;
    });

    const response = await fetch(`${baseURL}${fullPath}`);
    expect(response.status).toBe(200);

    const transaction = await transactionPromise;
    expect(transaction.transaction).toBe(`GET ${fullPath}`);

    const spans = transaction.spans || [];
    const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');

    expect(middlewareSpans).toHaveLength(2);

    const [spanA, spanB] = middlewareSpans.sort((a, b) => (a.description ?? '').localeCompare(b.description ?? ''));
    expect(spanA?.description).toBe('combinedInlineMw');
    expect(spanA?.op).toBe('middleware.hono');
    expect(spanA?.origin).toBe('auto.middleware.hono');
    expect(spanA?.status).not.toBe('internal_error');

    expect(spanB?.description).toBe('middlewareA');
    expect(spanB?.op).toBe('middleware.hono');
    expect(spanB?.origin).toBe('auto.middleware.hono');
    expect(spanB?.status).not.toBe('internal_error');
  });
});