feat(nestjs): Gracefully handle RPC scenarios in SentryGlobalFilter

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});

packages/nestjs/src/setup.ts

@@ -86,10 +86,12 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  * Catches exceptions and reports them to Sentry unless they are expected errors.
  */
  public catch(exception: unknown, host: ArgumentsHost): void {
+ const contextType = host.getType<string>();
+
  // The BaseExceptionFilter does not work well in GraphQL applications.
  // By default, Nest GraphQL applications use the ExternalExceptionFilter, which just rethrows the error:
  // https://github.com/nestjs/nest/blob/master/packages/core/exceptions/external-exception-filter.ts
- if (host.getType<'graphql'>() === 'graphql') {
+ if (contextType === 'graphql') {
  // neither report nor log HttpExceptions
  if (exception instanceof HttpException) {
  throw exception;
@@ -103,6 +105,39 @@ class SentryGlobalFilter extends BaseExceptionFilter {
  throw exception;
  }
 
+ // Handle microservice context (rpc)
+ // We cannot add proper handing here since RpcException depend on the @nestjs/microservices package
+ // For these cases we log a warning that the user should be providing a dedicated exception filter
+ if (contextType === 'rpc') {
+ // Unlikely case
+ if (exception instanceof HttpException) {
+ throw exception;
+ }
+
+ // Handle any other kind of error
+ if (!(exception instanceof Error)) {
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+ throw exception;
+ }
+
+ // In this case we're likely running into an RpcException, which the user should handle with a dedicated filter
+ // https://github.com/nestjs/nest/blob/master/sample/03-microservices/src/common/filters/rpc-exception.filter.ts
+ if (!isExpectedError(exception)) {
+ captureException(exception);
+ }
+
+ this._logger.warn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ // Log the error and return, otherwise we may crash the user's app by handling rpc errors in a http context
+ this._logger.error(exception.message, exception.stack);
+ return;
+ }
+
+ // HTTP exceptions
  if (!isExpectedError(exception)) {
  captureException(exception);
  }

packages/nestjs/test/sentry-global-filter.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ArgumentsHost } from '@nestjs/common';
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { SentryGlobalFilter } from '../src/setup';
+import * as SentryCore from '@sentry/core';
+import * as Helpers from '../src/helpers';
+
+vi.mock('../src/helpers', () => ({
+ isExpectedError: vi.fn(),
+}));
+
+vi.mock('@sentry/core', () => ({
+ captureException: vi.fn().mockReturnValue('mock-event-id'),
+ getIsolationScope: vi.fn(),
+ getDefaultIsolationScope: vi.fn(),
+ logger: {
+ warn: vi.fn(),
+ },
+}));
+
+describe('SentryGlobalFilter', () => {
+ let filter: SentryGlobalFilter;
+ let mockArgumentsHost: ArgumentsHost;
+ let mockHttpServer: any;
+ let mockCaptureException: any;
+ let mockLoggerError: any;
+ let mockLoggerWarn: any;
+ let isExpectedErrorMock: any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockHttpServer = {
+ getRequestMethod: vi.fn(),
+ getRequestUrl: vi.fn(),
+ };
+
+ filter = new SentryGlobalFilter(mockHttpServer);
+
+ mockArgumentsHost = {
+ getType: vi.fn().mockReturnValue('http'),
+ getArgs: vi.fn().mockReturnValue([]),
+ getArgByIndex: vi.fn().mockReturnValue({}),
+ switchToHttp: vi.fn().mockReturnValue({
+ getRequest: vi.fn().mockReturnValue({}),
+ getResponse: vi.fn().mockReturnValue({}),
+ getNext: vi.fn(),
+ }),
+ switchToRpc: vi.fn(),
+ switchToWs: vi.fn(),
+ } as unknown as ArgumentsHost;
+
+ mockLoggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => {});
+ mockLoggerWarn = vi.spyOn(Logger.prototype, 'warn').mockImplementation(() => {});
+
+ mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockReturnValue('mock-event-id');
+
+ isExpectedErrorMock = vi.mocked(Helpers.isExpectedError).mockImplementation(() => false);
+ });
+
+ describe('HTTP context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('http');
+ });
+
+ it('should capture non-HttpException errors and call super.catch for HTTP context', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const error = new Error('Test error');
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected errors', () => {
+ const originalCatch = filter.catch;
+ const superCatchSpy = vi.fn();
+
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ filter.catch = function (exception, host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+ superCatchSpy(exception, host);
+ return {} as any;
+ };
+
+ const expectedError = new Error('Test error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(superCatchSpy).toHaveBeenCalled();
+
+ filter.catch = originalCatch;
+ });
+ });
+
+ describe('GraphQL context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('graphql');
+ });
+
+ it('should throw HttpExceptions without capturing them', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerError).not.toHaveBeenCalled();
+ });
+
+ it('should log and capture non-HttpException errors in GraphQL context', () => {
+ const error = new Error('Test error');
+
+ expect(() => {
+ filter.catch(error, mockArgumentsHost);
+ }).toThrow(error);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+ });
+ });
+
+ describe('RPC context', () => {
+ beforeEach(() => {
+ vi.mocked(mockArgumentsHost.getType).mockReturnValue('rpc');
+ });
+
+ it('should log a warning for RPC exceptions', () => {
+ const error = new Error('Test RPC error');
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ filter.catch(error, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(error);
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(error.message, error.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should not capture expected RPC errors', () => {
+ isExpectedErrorMock.mockReturnValueOnce(true);
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ if (exception instanceof Error) {
+ mockLoggerError(exception.message, exception.stack);
+ }
+
+ mockLoggerWarn(
+ 'IMPORTANT: RpcException should be handled with a dedicated Rpc exception filter, not the generic SentryGlobalFilter',
+ );
+
+ return undefined as any;
+ };
+
+ const expectedError = new Error('Expected RPC error');
+
+ filter.catch(expectedError, mockArgumentsHost);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ expect(mockLoggerWarn).toHaveBeenCalled();
+ expect(mockLoggerError).toHaveBeenCalledWith(expectedError.message, expectedError.stack);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should handle non-Error objects in RPC context', () => {
+ const nonErrorObject = { message: 'Not an Error object' };
+
+ const originalCatch = filter.catch;
+ filter.catch = function (exception, _host) {
+ if (!Helpers.isExpectedError(exception)) {
+ SentryCore.captureException(exception);
+ }
+
+ return undefined as any;
+ };
+
+ filter.catch(nonErrorObject, mockArgumentsHost);
+
+ expect(mockCaptureException).toHaveBeenCalledWith(nonErrorObject);
+
+ filter.catch = originalCatch;
+ });
+
+ it('should throw HttpExceptions in RPC context without capturing', () => {
+ const httpException = new HttpException('Test HTTP exception', HttpStatus.BAD_REQUEST);
+
+ expect(() => {
+ filter.catch(httpException, mockArgumentsHost);
+ }).toThrow(httpException);
+
+ expect(mockCaptureException).not.toHaveBeenCalled();
+ });
+ });
+});