@rxap/nest-sentry 11.0.0-dev.5 → 11.0.0-dev.7

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [11.0.0-dev.7](https://gitlab.com/rxap/packages/compare/@rxap/nest-sentry@11.0.0-dev.6...@rxap/nest-sentry@11.0.0-dev.7) (2025-09-08)
+
+### Features
+
+- **nest-sentry:** upgrade to sentry 10 ([2302e70](https://gitlab.com/rxap/packages/commit/2302e70ee4ac4e13b925d812de762d3b6c5a8968))
+
+# [11.0.0-dev.6](https://gitlab.com/rxap/packages/compare/@rxap/nest-sentry@11.0.0-dev.5...@rxap/nest-sentry@11.0.0-dev.6) (2025-09-01)
+
+**Note:** Version bump only for package @rxap/nest-sentry
+
 # [11.0.0-dev.5](https://gitlab.com/rxap/packages/compare/@rxap/nest-sentry@11.0.0-dev.4...@rxap/nest-sentry@11.0.0-dev.5) (2025-07-02)
 
 ### Bug Fixes

package/package.json

@@ -1,11 +1,11 @@
 {
-  "version": "11.0.0-dev.5",
+  "version": "11.0.0-dev.7",
   "name": "@rxap/nest-sentry",
   "description": "This package provides a Sentry integration for NestJS applications. It includes a logger, interceptor, and module to simplify error tracking and performance monitoring with Sentry. It offers configurable options for setting up Sentry in your NestJS application.\n",
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "@nx/devkit": "20.5.0",
-    "@rxap/ts-morph": "^1.5.6-dev.0",
+    "@rxap/ts-morph": "^1.6.0-dev.0",
     "@rxap/workspace-utilities": "^19.8.1-dev.0",
     "tslib": "2.6.2"
   },
@@ -13,8 +13,8 @@
     "@nestjs/common": "^11.1.1",
     "@nestjs/config": "^4.0.2",
     "@nestjs/core": "^11.1.1",
-    "@rxap/nest-logger": "^11.0.0-dev.2",
-    "@rxap/nest-utilities": "^11.0.0-dev.2",
+    "@rxap/nest-logger": "^11.0.0-dev.3",
+    "@rxap/nest-utilities": "^11.0.0-dev.5",
     "@sentry/core": "^8.55.0",
     "@sentry/nestjs": "^8.55.0",
     "@sentry/node": "^8.55.0",
@@ -81,11 +81,11 @@
       },
       {
         "package": "@rxap/nest-logger",
-        "version": "11.0.0-dev.2"
+        "version": "11.0.0-dev.3"
       },
       {
         "package": "@rxap/nest-utilities",
-        "version": "11.0.0-dev.2"
+        "version": "11.0.0-dev.5"
       },
       {
         "package": "@rxap/utilities",
@@ -128,7 +128,7 @@
   },
   "schematics": "./generators.json",
   "type": "commonjs",
-  "gitHead": "7192244e6d863ca19e17a5ad8e6d8e916acd9f72",
+  "gitHead": "34740039c547dace5fe51410d0a3d445a6661622",
   "types": "./src/index.d.ts",
   "main": "./src/index.js"
 }

package/src/index.d.ts

@@ -1,15 +1,11 @@
 export * from './lib/determine-sentry-environment';
 export * from './lib/determine-sentry-release';
+export * from './lib/get-sentry-log-levels';
 export * from './lib/sentry-app-config';
 export * from './lib/sentry-init-hook';
-export * from './lib/sentry-logger.module';
-export * from './lib/sentry-options.factory';
-export * from './lib/sentry.interceptor';
+export * from './lib/sentry-module-options.factory';
 export * from './lib/sentry.interfaces';
 export * from './lib/sentry.logger';
 export * from './lib/sentry.module';
-export * from './lib/sentry.service';
-export * from './lib/setup-sentry-error-handler';
-export * from './lib/setup-sentry-logger';
 export * from './lib/tokens';
 export * from './lib/use-sentry-logger-factory';

package/src/index.js

@@ -4,17 +4,13 @@ const tslib_1 = require("tslib");
 // region 
 tslib_1.__exportStar(require("./lib/determine-sentry-environment"), exports);
 tslib_1.__exportStar(require("./lib/determine-sentry-release"), exports);
+tslib_1.__exportStar(require("./lib/get-sentry-log-levels"), exports);
 tslib_1.__exportStar(require("./lib/sentry-app-config"), exports);
 tslib_1.__exportStar(require("./lib/sentry-init-hook"), exports);
-tslib_1.__exportStar(require("./lib/sentry-logger.module"), exports);
-tslib_1.__exportStar(require("./lib/sentry-options.factory"), exports);
-tslib_1.__exportStar(require("./lib/sentry.interceptor"), exports);
+tslib_1.__exportStar(require("./lib/sentry-module-options.factory"), exports);
 tslib_1.__exportStar(require("./lib/sentry.interfaces"), exports);
 tslib_1.__exportStar(require("./lib/sentry.logger"), exports);
 tslib_1.__exportStar(require("./lib/sentry.module"), exports);
-tslib_1.__exportStar(require("./lib/sentry.service"), exports);
-tslib_1.__exportStar(require("./lib/setup-sentry-error-handler"), exports);
-tslib_1.__exportStar(require("./lib/setup-sentry-logger"), exports);
 tslib_1.__exportStar(require("./lib/tokens"), exports);
 tslib_1.__exportStar(require("./lib/use-sentry-logger-factory"), exports);
 // endregion

package/src/lib/get-sentry-log-levels.d.ts

@@ -0,0 +1,2 @@
+import { LogSeverityLevel } from '@sentry/core';
+export declare function GetSentryLogLevels(sentryLogLevel?: string | undefined): LogSeverityLevel[];

package/src/lib/get-sentry-log-levels.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSentryLogLevels = GetSentryLogLevels;
+function GetSentryLogLevels(sentryLogLevel = process.env['SENTRY_LOG_LEVEL']) {
+    const logLevels = [];
+    switch (sentryLogLevel?.toLowerCase()) {
+        case 'verbose':
+        case 'trace':
+            logLevels.push('trace');
+            logLevels.push('debug');
+            logLevels.push('info');
+            logLevels.push('warn');
+            logLevels.push('error');
+            logLevels.push('fatal');
+            break;
+        case 'debug':
+            logLevels.push('debug');
+            logLevels.push('info');
+            logLevels.push('warn');
+            logLevels.push('error');
+            logLevels.push('fatal');
+            break;
+        case 'log':
+        case 'info':
+            logLevels.push('info');
+            logLevels.push('warn');
+            logLevels.push('error');
+            logLevels.push('fatal');
+            break;
+        default:
+        case 'warn':
+            logLevels.push('warn');
+            logLevels.push('error');
+            logLevels.push('fatal');
+            break;
+        case 'error':
+            logLevels.push('error');
+            logLevels.push('fatal');
+            break;
+        case 'fatal':
+            logLevels.push('fatal');
+            break;
+    }
+    console.debug('SentryLogLevels:', logLevels.join(', '));
+    return logLevels;
+}

package/src/lib/sentry-app-config.d.ts

@@ -1,11 +1,6 @@
 import { Environment } from '@rxap/nest-utilities';
+import { LogSeverityLevel } from '@sentry/core';
 import type { SchemaMap } from 'joi';
-export interface SentryConfig {
-    debug: boolean;
-    serverName: string;
-    release: string;
-    environment: string;
-    enabled: boolean;
-    dsn: string;
-}
-export declare function sentryValidationSchema(environment: Environment, { debug, serverName, release, environment: environmentName, enabled, dsn, }?: Partial<SentryConfig>): SchemaMap;
+export declare function sentryValidationSchema(environment: Environment, { logLevel }?: Partial<{
+    logLevel: LogSeverityLevel;
+}>): SchemaMap;

package/src/lib/sentry-app-config.js

@@ -2,22 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sentryValidationSchema = sentryValidationSchema;
 const Joi = require("joi");
-function sentryValidationSchema(environment, { debug = environment.sentry?.debug ?? false, serverName = environment.sentry?.serverName ?? process.env['ROOT_DOMAIN'] ?? environment.app, release = environment.sentry?.release, environment: environmentName = environment.sentry?.environment, enabled = environment.sentry?.enabled ?? false, dsn = environment.sentry?.dsn, } = {}) {
+function sentryValidationSchema(environment, { logLevel = 'warn' } = {}) {
     const schema = {};
-    schema['SENTRY_DEBUG'] = Joi.string().default(debug);
-    schema['SENTRY_SERVER_NAME'] = Joi.string().default(serverName);
-    schema['SENTRY_ENABLED'] = Joi.string().default(enabled);
-    schema['SENTRY_RELEASE'] = Joi.string();
-    if (release) {
-        schema['SENTRY_RELEASE'] = schema['SENTRY_RELEASE'].default(release);
-    }
-    schema['SENTRY_ENVIRONMENT'] = Joi.string();
-    if (environmentName) {
-        schema['SENTRY_ENVIRONMENT'] = schema['SENTRY_ENVIRONMENT'].default(environmentName);
-    }
-    schema['SENTRY_DSN'] = Joi.string();
-    if (dsn) {
-        schema['SENTRY_DSN'] = schema['SENTRY_DSN'].default(dsn);
-    }
+    schema['SENTRY_LOG_LEVEL'] = Joi.string().allow('trace', 'debug', 'info', 'warn', 'error', 'fatal').default(logLevel);
     return schema;
 }

package/src/lib/sentry-init-hook.d.ts

@@ -1,2 +1,3 @@
 import { Environment } from '@rxap/nest-utilities';
-export declare function sentryInitHook(): (_: any, environment: Environment) => void;
+import type { NodeOptions } from '@sentry/node/build/types/types';
+export declare function sentryInitHook(options: Partial<NodeOptions>): (_: any, environment: Environment) => void;

package/src/lib/sentry-init-hook.js

@@ -5,7 +5,7 @@ const Sentry = require("@sentry/nestjs");
 const profiling_node_1 = require("@sentry/profiling-node");
 const determine_sentry_environment_1 = require("./determine-sentry-environment");
 const determine_sentry_release_1 = require("./determine-sentry-release");
-function sentryInitHook() {
+function sentryInitHook(options) {
     return (_, environment) => {
         const dsn = process.env['SENTRY_DSN'] ?? environment.sentry?.dsn;
         if (!dsn) {
@@ -24,10 +24,12 @@ function sentryInitHook() {
                     levels: ['error'],
                 }),
                 (0, profiling_node_1.nodeProfilingIntegration)(),
-                Sentry.anrIntegration({ captureStackTrace: true }),
             ],
             tracesSampleRate: 1.0,
-            profilesSampleRate: 1.0,
+            profileSessionSampleRate: 1.0,
+            profileLifecycle: 'trace',
+            enableLogs: true,
+            ...options,
         });
     };
 }

package/src/lib/sentry-module-options.factory.d.ts

@@ -0,0 +1,10 @@
+import { ConfigurableModuleOptionsFactory, Logger } from '@nestjs/common';
+import { ConsoleLoggerOptions } from '@nestjs/common/services/console-logger.service';
+import { ConfigService } from '@nestjs/config';
+import { SentryModuleOptions } from '@rxap/nest-sentry';
+export declare class SentryModuleOptionsFactory implements ConfigurableModuleOptionsFactory<SentryModuleOptions, 'create'> {
+    protected readonly config: ConfigService;
+    protected readonly logger: Logger;
+    protected readonly options?: ConsoleLoggerOptions;
+    create(): Promise<SentryModuleOptions>;
+}

package/src/lib/sentry-module-options.factory.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SentryModuleOptionsFactory = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const nest_logger_1 = require("@rxap/nest-logger");
+const nest_utilities_1 = require("@rxap/nest-utilities");
+const get_sentry_log_levels_1 = require("./get-sentry-log-levels");
+let SentryModuleOptionsFactory = class SentryModuleOptionsFactory {
+    async create() {
+        return {
+            logLevels: (0, get_sentry_log_levels_1.GetSentryLogLevels)(this.config.getOrThrow('SENTRY_LOG_LEVEL')),
+            logger: {
+                timestamp: true,
+                logLevels: (0, nest_utilities_1.GetLogLevels)(),
+                ...this.options ?? {},
+            }
+        };
+    }
+};
+exports.SentryModuleOptionsFactory = SentryModuleOptionsFactory;
+tslib_1.__decorate([
+    (0, common_1.Inject)(config_1.ConfigService),
+    tslib_1.__metadata("design:type", config_1.ConfigService)
+], SentryModuleOptionsFactory.prototype, "config", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(common_1.Logger),
+    tslib_1.__metadata("design:type", common_1.Logger)
+], SentryModuleOptionsFactory.prototype, "logger", void 0);
+tslib_1.__decorate([
+    (0, common_1.Optional)(),
+    (0, common_1.Inject)(nest_logger_1.CONSOLE_LOGGER_OPTIONS),
+    tslib_1.__metadata("design:type", Object)
+], SentryModuleOptionsFactory.prototype, "options", void 0);
+exports.SentryModuleOptionsFactory = SentryModuleOptionsFactory = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], SentryModuleOptionsFactory);

package/src/lib/sentry.interfaces.d.ts

@@ -1,41 +1,6 @@
 import { ConsoleLoggerOptions } from '@nestjs/common';
-import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
-import { NodeOptions, SeverityLevel } from '@sentry/node';
-import { Integration } from '@sentry/types';
-import { AddRequestDataToEventOptions } from '@sentry/utils';
-export interface SentryCloseOptions {
-    enabled: boolean;
-    timeout?: number;
-}
-export type SentryModuleOptions = Omit<NodeOptions, 'integrations'> & {
-    integrations?: Integration[];
-    close?: SentryCloseOptions;
-    interceptors?: SentryInterceptorOptions;
-} & ConsoleLoggerOptions;
-export interface ISentryOptionsFactory {
-    createSentryModuleOptions(): Promise<SentryModuleOptions> | SentryModuleOptions;
-}
-export interface SentryModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    inject?: any[];
-    useClass?: Type<ISentryOptionsFactory>;
-    useExisting?: Type<ISentryOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<SentryModuleOptions> | SentryModuleOptions;
-}
-export interface SentryFilterFunction {
-    (exception: any): boolean;
-}
-export interface SentryInterceptorOptionsFilter {
-    type: any;
-    filter?: SentryFilterFunction;
-}
-export type SentryInterceptorOptions = AddRequestDataToEventOptions['include'] & {
-    filters?: SentryInterceptorOptionsFilter[];
-    tags?: {
-        [key: string]: string;
-    };
-    extra?: {
-        [key: string]: any;
-    };
-    fingerprint?: string[];
-    level?: SeverityLevel;
+import { LogSeverityLevel } from '@sentry/core';
+export type SentryModuleOptions = {
+    logLevels: LogSeverityLevel[];
+    logger?: ConsoleLoggerOptions;
 };

package/src/lib/sentry.logger.d.ts

@@ -8,10 +8,13 @@ import { RxapLogger } from '@rxap/nest-logger';
 export declare class SentryLogger extends RxapLogger {
     protected readonly options: ConsoleLoggerOptions;
     private readonly sentryOptions;
+    private readonly config;
     log(message: string, ...optionalParams: any[]): void;
     error(message: string, ...optionalParams: any[]): void;
+    fatal(message: string, ...optionalParams: any[]): void;
     warn(message: string, ...optionalParams: any[]): void;
     debug(message: string, ...optionalParams: any[]): void;
+    verbose(message: string, ...optionalParams: any[]): void;
     private _getContextAndMessagesToPrint;
     private _getContextAndStackAndMessagesToPrint;
 }

package/src/lib/sentry.logger.js

@@ -4,6 +4,7 @@ exports.SentryLogger = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const config_1 = require("@nestjs/config");
 const nest_logger_1 = require("@rxap/nest-logger");
 const Sentry = require("@sentry/node");
 const tokens_1 = require("./tokens");
@@ -25,10 +26,10 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
             ...optionalParams,
         ]);
         super.log(message, ...optionalParams);
-        if (!this.sentryOptions.dsn) {
+        if (!this.config.get('SENTRY_ENABLED')) {
             return;
         }
-        if (this.sentryOptions.logLevels && !this.sentryOptions.logLevels.includes('log')) {
+        if (this.sentryOptions.logLevels && !['log', 'info'].some(level => this.sentryOptions.logLevels.includes(level))) {
             return;
         }
         try {
@@ -39,11 +40,7 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
                     data: {
                         context,
                     },
-                }) :
-                Sentry.captureMessage(message, {
-                    level: 'log',
-                    extra: { context },
-                });
+                }) : Sentry.logger.info(message, { data: context });
         }
         catch (err) {
             console.error('Failed to capture message with sentry: ' + err.message);
@@ -55,16 +52,39 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
             ...optionalParams,
         ]);
         super.error(message, ...optionalParams);
-        if (!this.sentryOptions.dsn) {
+        if (!this.config.get('SENTRY_ENABLED')) {
             return;
         }
         if (this.sentryOptions.logLevels && !this.sentryOptions.logLevels.includes('error')) {
             return;
         }
         try {
-            Sentry.captureMessage(message, {
-                level: 'error',
-                extra: {
+            Sentry.logger.error(message, {
+                data: {
+                    context,
+                    stack,
+                },
+            });
+        }
+        catch (err) {
+            console.error('Failed to capture message with sentry: ' + err.message);
+        }
+    }
+    fatal(message, ...optionalParams) {
+        const { context, stack, } = this._getContextAndStackAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        super.error(message, ...optionalParams);
+        if (!this.config.get('SENTRY_ENABLED')) {
+            return;
+        }
+        if (this.sentryOptions.logLevels && !this.sentryOptions.logLevels.includes('fatal')) {
+            return;
+        }
+        try {
+            Sentry.logger.fatal(message, {
+                data: {
                     context,
                     stack,
                 },
@@ -86,10 +106,10 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
             ...optionalParams,
         ]);
         super.warn(message, ...optionalParams);
-        if (!this.sentryOptions.dsn) {
+        if (!this.config.get('SENTRY_ENABLED')) {
             return;
         }
-        if (this.sentryOptions.logLevels && !this.sentryOptions.logLevels.includes('warn')) {
+        if (this.sentryOptions.logLevels && !['warn', 'warning'].some(level => this.sentryOptions.logLevels.includes(level))) {
             return;
         }
         try {
@@ -101,9 +121,8 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
                         context,
                     },
                 }) :
-                Sentry.captureMessage(message, {
-                    level: 'warning',
-                    extra: { context },
+                Sentry.logger.warn(message, {
+                    data: { context },
                 });
         }
         catch (err) {
@@ -122,7 +141,7 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
             ...optionalParams,
         ]);
         super.debug(message, ...optionalParams);
-        if (!this.sentryOptions.dsn) {
+        if (!this.config.get('SENTRY_ENABLED')) {
             return;
         }
         if (this.sentryOptions.logLevels && !this.sentryOptions.logLevels.includes('debug')) {
@@ -137,15 +156,35 @@ let SentryLogger = class SentryLogger extends nest_logger_1.RxapLogger {
                         context,
                     },
                 }) :
-                Sentry.captureMessage(message, {
-                    level: 'debug',
-                    extra: { context },
+                Sentry.logger.debug(message, {
+                    data: { context },
                 });
         }
         catch (err) {
             console.error('Failed to capture message with sentry: ' + err.message);
         }
     }
+    verbose(message, ...optionalParams) {
+        const { context } = this._getContextAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        super.verbose(message, ...optionalParams);
+        if (!this.config.get('SENTRY_ENABLED')) {
+            return;
+        }
+        if (this.sentryOptions.logLevels && !['verbose', 'trace'].some(level => this.sentryOptions.logLevels.includes(level))) {
+            return;
+        }
+        try {
+            Sentry.logger.trace(message, {
+                data: { context },
+            });
+        }
+        catch (err) {
+            console.error('Failed to capture message with sentry: ' + err.message);
+        }
+    }
     _getContextAndMessagesToPrint(args) {
         if (args?.length <= 1) {
             return {
@@ -199,6 +238,10 @@ tslib_1.__decorate([
     (0, common_1.Inject)(tokens_1.SENTRY_MODULE_OPTIONS),
     tslib_1.__metadata("design:type", Object)
 ], SentryLogger.prototype, "sentryOptions", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(config_1.ConfigService),
+    tslib_1.__metadata("design:type", config_1.ConfigService)
+], SentryLogger.prototype, "config", void 0);
 exports.SentryLogger = SentryLogger = tslib_1.__decorate([
     (0, common_1.Injectable)()
 ], SentryLogger);

package/src/lib/sentry.module.d.ts

@@ -1,22 +1,15 @@
-import { ConsoleLoggerOptions, DynamicModule } from '@nestjs/common';
+import { DynamicModule } from '@nestjs/common';
 import { PrintMessagesFunction } from '@rxap/nest-logger';
-import { SentryInterceptorOptions, SentryModuleOptions } from './sentry.interfaces';
+import { SentryModuleOptions } from './sentry.interfaces';
 export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<SentryModuleOptions, "register", "create", {
     isGlobal: boolean;
-}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: Omit<import("@sentry/node").NodeOptions, "integrations"> & {
-    integrations?: import("@sentry/types").Integration[];
-    close?: import("./sentry.interfaces").SentryCloseOptions;
-    interceptors?: SentryInterceptorOptions;
-} & ConsoleLoggerOptions & Partial<{
+}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: SentryModuleOptions & Partial<{
     isGlobal: boolean;
 }>, ASYNC_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<SentryModuleOptions, "create"> & Partial<{
     isGlobal: boolean;
 }>;
-export declare const DEFAULT_SENTRY_INTERCEPTOR_OPTIONS: SentryInterceptorOptions;
 export declare class SentryModule extends ConfigurableModuleClass {
-    static register(options?: typeof OPTIONS_TYPE, consoleLoggerOptions?: ConsoleLoggerOptions, printMessagesFunction?: PrintMessagesFunction | null): DynamicModule;
-    static registerAsync(options: typeof ASYNC_OPTIONS_TYPE, consoleLoggerOptions?: ConsoleLoggerOptions, printMessagesFunction?: PrintMessagesFunction | null): DynamicModule;
+    static register(options: typeof OPTIONS_TYPE, printMessagesFunction?: PrintMessagesFunction | null): DynamicModule;
+    static registerAsync(options: typeof ASYNC_OPTIONS_TYPE, printMessagesFunction?: PrintMessagesFunction | null): DynamicModule;
     private static updateProviders;
-    static forRoot(options: typeof OPTIONS_TYPE, consoleLoggerOptions?: ConsoleLoggerOptions): DynamicModule;
-    static forRootAsync(options: typeof ASYNC_OPTIONS_TYPE, consoleLoggerOptions?: ConsoleLoggerOptions): DynamicModule;
 }

package/src/lib/sentry.module.js

@@ -1,13 +1,12 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentryModule = exports.DEFAULT_SENTRY_INTERCEPTOR_OPTIONS = exports.ASYNC_OPTIONS_TYPE = exports.OPTIONS_TYPE = exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+exports.SentryModule = exports.ASYNC_OPTIONS_TYPE = exports.OPTIONS_TYPE = exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
-const core_1 = require("@nestjs/core");
 const nest_logger_1 = require("@rxap/nest-logger");
-const sentry_interceptor_1 = require("./sentry.interceptor");
+const nest_utilities_1 = require("@rxap/nest-utilities");
 const sentry_logger_1 = require("./sentry.logger");
 const tokens_1 = require("./tokens");
 _a = new common_1.ConfigurableModuleBuilder()
@@ -15,22 +14,14 @@ _a = new common_1.ConfigurableModuleBuilder()
     isGlobal: true,
 })
     .build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN, exports.OPTIONS_TYPE = _a.OPTIONS_TYPE, exports.ASYNC_OPTIONS_TYPE = _a.ASYNC_OPTIONS_TYPE;
-exports.DEFAULT_SENTRY_INTERCEPTOR_OPTIONS = {
-    filters: [
-        {
-            type: common_1.HttpException,
-            filter: (exception) => 500 > exception.getStatus(),
-        },
-    ],
-};
 let SentryModule = class SentryModule extends exports.ConfigurableModuleClass {
-    static register(options = {}, consoleLoggerOptions = {}, printMessagesFunction = null) {
-        return this.updateProviders(super.register(options), consoleLoggerOptions, printMessagesFunction);
+    static register(options, printMessagesFunction = null) {
+        return this.updateProviders(super.register(options), printMessagesFunction);
     }
-    static registerAsync(options, consoleLoggerOptions = {}, printMessagesFunction = null) {
-        return this.updateProviders(super.registerAsync(options), consoleLoggerOptions, printMessagesFunction);
+    static registerAsync(options, printMessagesFunction = null) {
+        return this.updateProviders(super.registerAsync(options), printMessagesFunction);
     }
-    static updateProviders(module, { timestamp, logLevels, ...consoleLoggerOptions }, printMessagesFunction) {
+    static updateProviders(module, printMessagesFunction) {
         module.providers ??= [];
         module.providers.push({
             provide: tokens_1.SENTRY_MODULE_OPTIONS,
@@ -38,16 +29,12 @@ let SentryModule = class SentryModule extends exports.ConfigurableModuleClass {
         });
         module.providers.push({
             provide: nest_logger_1.CONSOLE_LOGGER_OPTIONS,
-            useValue: {
-                ...consoleLoggerOptions,
-                timestamp: timestamp ?? true,
-                logLevels: logLevels ?? ['log', 'error', 'warn'],
-            },
-        });
-        module.providers.push({
-            provide: tokens_1.SENTRY_INTERCEPTOR_OPTIONS,
-            useFactory: (options) => options.interceptors ?? exports.DEFAULT_SENTRY_INTERCEPTOR_OPTIONS,
-            inject: [exports.MODULE_OPTIONS_TOKEN]
+            useFactory: (options) => ({
+                timestamp: true,
+                logLevels: (0, nest_utilities_1.GetLogLevels)(),
+                ...options.logger ?? {},
+            }),
+            inject: [tokens_1.SENTRY_MODULE_OPTIONS],
         });
         if (printMessagesFunction) {
             module.providers.push({
@@ -55,18 +42,8 @@ let SentryModule = class SentryModule extends exports.ConfigurableModuleClass {
                 useValue: printMessagesFunction
             });
         }
-        module.providers.push({
-            provide: core_1.APP_INTERCEPTOR,
-            useClass: sentry_interceptor_1.SentryInterceptor,
-        });
         return module;
     }
-    static forRoot(options, consoleLoggerOptions = {}) {
-        return this.register(options, consoleLoggerOptions);
-    }
-    static forRootAsync(options, consoleLoggerOptions = {}) {
-        return this.registerAsync(options, consoleLoggerOptions);
-    }
 };
 exports.SentryModule = SentryModule;
 exports.SentryModule = SentryModule = tslib_1.__decorate([
@@ -88,6 +65,7 @@ exports.SentryModule = SentryModule = tslib_1.__decorate([
             sentry_logger_1.SentryLogger,
             nest_logger_1.RxapLogger,
         ],
+        imports: [],
         exports: [common_1.Logger],
     })
 ], SentryModule);

package/src/lib/tokens.d.ts

@@ -1,5 +1 @@
 export declare const SENTRY_MODULE_OPTIONS: unique symbol;
-/**
- * InjectionToken for an object of type SentryInterceptorOptions
- */
-export declare const SENTRY_INTERCEPTOR_OPTIONS: unique symbol;

package/src/lib/tokens.js

@@ -1,8 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SENTRY_INTERCEPTOR_OPTIONS = exports.SENTRY_MODULE_OPTIONS = void 0;
+exports.SENTRY_MODULE_OPTIONS = void 0;
 exports.SENTRY_MODULE_OPTIONS = Symbol('SentryModuleOptions');
-/**
- * InjectionToken for an object of type SentryInterceptorOptions
- */
-exports.SENTRY_INTERCEPTOR_OPTIONS = Symbol('SENTRY_INTERCEPTOR_OPTIONS');

package/src/lib/sentry-logger.module.d.ts

@@ -1,5 +0,0 @@
-/**
- * @deprecated removed use the SentryModule instead
- */
-export declare class SentryLoggerModule {
-}

package/src/lib/sentry-logger.module.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentryLoggerModule = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const config_1 = require("@nestjs/config");
-const nest_logger_1 = require("@rxap/nest-logger");
-const sentry_logger_1 = require("./sentry.logger");
-/**
- * @deprecated removed use the SentryModule instead
- */
-let SentryLoggerModule = class SentryLoggerModule {
-};
-exports.SentryLoggerModule = SentryLoggerModule;
-exports.SentryLoggerModule = SentryLoggerModule = tslib_1.__decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({
-        providers: [
-            {
-                provide: common_1.Logger,
-                useFactory: (config, sentry, rxap) => {
-                    if (config.get('SENTRY_ENABLED')) {
-                        return sentry;
-                    }
-                    else {
-                        return rxap;
-                    }
-                },
-                inject: [config_1.ConfigService, sentry_logger_1.SentryLogger, nest_logger_1.RxapLogger]
-            },
-            sentry_logger_1.SentryLogger,
-            nest_logger_1.RxapLogger,
-        ],
-        exports: [common_1.Logger],
-    })
-], SentryLoggerModule);

package/src/lib/sentry-options.factory.d.ts

@@ -1,4 +0,0 @@
-import { ConfigService } from '@nestjs/config';
-import { Environment } from '@rxap/nest-utilities';
-import { SentryModuleOptions } from './sentry.interfaces';
-export declare function SentryOptionsFactory(environment: Environment): (config: ConfigService) => SentryModuleOptions;

package/src/lib/sentry-options.factory.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentryOptionsFactory = SentryOptionsFactory;
-const nest_utilities_1 = require("@rxap/nest-utilities");
-function SentryOptionsFactory(environment) {
-    return (config) => {
-        const options = {
-            dsn: config.get('SENTRY_DSN'),
-            enabled: config.get('SENTRY_ENABLED', false),
-            environment: config.get('SENTRY_ENVIRONMENT', (0, nest_utilities_1.DetermineEnvironment)(environment)),
-            release: config.get('SENTRY_RELEASE', (0, nest_utilities_1.DetermineRelease)(environment)),
-            serverName: config.get('SENTRY_SERVER_NAME', environment.name),
-            debug: config.get('SENTRY_DEBUG', false),
-            tracesSampleRate: config.get('SENTRY_TRACES_SAMPLE_RATE', 1.0),
-            profilesSampleRate: config.get('SENTRY_PROFILES_SAMPLE_RATE', 1.0),
-            logLevels: config.get('SENTRY_LOG_LEVELS', ['warn', 'error']),
-            maxValueLength: config.get('SENTRY_MAX_VALUE_LENGTH', Number.MAX_SAFE_INTEGER),
-            normalizeDepth: config.get('SENTRY_NORMALIZE_DEPTH', 5),
-        };
-        console.debug(`[SentryOptionsFactory] SentryOptions: ${JSON.stringify(options)}`);
-        return options;
-    };
-}

package/src/lib/sentry.interceptor.d.ts

@@ -1,13 +0,0 @@
-import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
-import { Scope } from '@sentry/core';
-import { Observable } from 'rxjs';
-import { SentryInterceptorOptions } from './sentry.interfaces';
-export declare class SentryInterceptor implements NestInterceptor {
-    protected readonly options?: SentryInterceptorOptions;
-    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
-    protected captureException(context: ExecutionContext, scope: Scope, exception: unknown): void;
-    private captureHttpException;
-    private captureRpcException;
-    private captureWsException;
-    private shouldReport;
-}

package/src/lib/sentry.interceptor.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentryInterceptor = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const Sentry = require("@sentry/nestjs");
-const node_1 = require("@sentry/node");
-const operators_1 = require("rxjs/operators");
-const tokens_1 = require("./tokens");
-let SentryInterceptor = class SentryInterceptor {
-    intercept(context, next) {
-        return next.handle().pipe((0, operators_1.tap)({
-            error: (exception) => {
-                if (this.shouldReport(exception)) {
-                    Sentry.withScope((scope) => {
-                        return this.captureException(context, scope, exception);
-                    });
-                }
-            },
-        }));
-    }
-    captureException(context, scope, exception) {
-        if (exception && typeof exception === 'object' && typeof exception['setScope'] === 'function') {
-            exception['setScope'](scope);
-        }
-        switch (context.getType()) {
-            case 'http':
-                return this.captureHttpException(scope, context.switchToHttp(), exception);
-            case 'rpc':
-                return this.captureRpcException(scope, context.switchToRpc(), exception);
-            case 'ws':
-                return this.captureWsException(scope, context.switchToWs(), exception);
-        }
-    }
-    captureHttpException(scope, http, exception) {
-        const data = (0, node_1.addRequestDataToEvent)({}, http.getRequest(), { include: this.options });
-        scope.setExtra('req', data.request);
-        if (data.extra) {
-            scope.setExtras(data.extra);
-        }
-        if (data.user) {
-            scope.setUser(data.user);
-        }
-        Sentry.captureException(exception);
-    }
-    captureRpcException(scope, rpc, exception) {
-        scope.setExtra('rpc_data', rpc.getData());
-        Sentry.captureException(exception);
-    }
-    captureWsException(scope, ws, exception) {
-        scope.setExtra('ws_client', ws.getClient());
-        scope.setExtra('ws_data', ws.getData());
-        Sentry.captureException(exception);
-    }
-    shouldReport(exception) {
-        if (!this.options?.filters) {
-            return true;
-        }
-        return this.options.filters
-            .some(({ type, filter, }) => !(exception instanceof type && (!filter || filter(exception))));
-    }
-};
-exports.SentryInterceptor = SentryInterceptor;
-tslib_1.__decorate([
-    (0, common_1.Optional)(),
-    (0, common_1.Inject)(tokens_1.SENTRY_INTERCEPTOR_OPTIONS),
-    tslib_1.__metadata("design:type", Object)
-], SentryInterceptor.prototype, "options", void 0);
-exports.SentryInterceptor = SentryInterceptor = tslib_1.__decorate([
-    (0, common_1.Injectable)()
-], SentryInterceptor);

package/src/lib/sentry.service.d.ts

@@ -1,10 +0,0 @@
-import { OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
-import * as Sentry from "@sentry/nestjs";
-export declare class SentryService implements OnApplicationShutdown, OnApplicationBootstrap {
-    private readonly options;
-    private readonly logger;
-    get hasInstance(): boolean;
-    onApplicationBootstrap(): any;
-    instance(): typeof Sentry;
-    onApplicationShutdown(signal?: string): Promise<void>;
-}

package/src/lib/sentry.service.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentryService = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const tokens_1 = require("./tokens");
-const Sentry = require("@sentry/nestjs");
-const profiling_node_1 = require("@sentry/profiling-node");
-let SentryService = class SentryService {
-    get hasInstance() {
-        return !!this.options.dsn;
-    }
-    onApplicationBootstrap() {
-        if (!this.options.dsn) {
-            if (this.options.enabled !== false) {
-                this.logger.warn('Could not create SentryService instance. The required option dsn is not defined', 'SentryService');
-            }
-            else {
-                this.logger.verbose('Dsn is not defined, but sentry is disabled', 'SentryService');
-            }
-            return;
-        }
-        const { integrations = [], ...sentryOptions } = this.options;
-        Sentry.init({
-            ...sentryOptions,
-            integrations: [
-                (0, profiling_node_1.nodeProfilingIntegration)(),
-                Sentry.onUncaughtExceptionIntegration({
-                    onFatalError: async (err) => {
-                        // console.error('uncaughtException, not cool!')
-                        // console.error(err);
-                        if (err.name === 'SentryError') {
-                            console.log(err);
-                        }
-                        else {
-                            Sentry.getCurrentHub().getClient().captureException(err);
-                            process.exit(1);
-                        }
-                    },
-                }),
-                Sentry.onUnhandledRejectionIntegration({ mode: 'warn' }),
-                ...integrations,
-            ],
-        });
-    }
-    instance() {
-        return Sentry;
-    }
-    async onApplicationShutdown(signal) {
-        if (this.hasInstance && this.options.close?.enabled === true) {
-            await Sentry.close(this.options.close.timeout);
-        }
-    }
-};
-exports.SentryService = SentryService;
-tslib_1.__decorate([
-    (0, common_1.Inject)(tokens_1.SENTRY_MODULE_OPTIONS),
-    tslib_1.__metadata("design:type", Object)
-], SentryService.prototype, "options", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(common_1.Logger),
-    tslib_1.__metadata("design:type", common_1.Logger)
-], SentryService.prototype, "logger", void 0);
-exports.SentryService = SentryService = tslib_1.__decorate([
-    (0, common_1.Injectable)()
-], SentryService);

package/src/lib/setup-sentry-error-handler.d.ts

@@ -1,2 +0,0 @@
-import { INestApplication } from '@nestjs/common';
-export declare function SetupSentryErrorHandler(): (app: INestApplication) => void;

package/src/lib/setup-sentry-error-handler.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetupSentryErrorHandler = SetupSentryErrorHandler;
-const core_1 = require("@nestjs/core");
-const Sentry = require("@sentry/nestjs");
-function SetupSentryErrorHandler() {
-    return (app) => {
-        const { httpAdapter } = app.get(core_1.HttpAdapterHost);
-        Sentry.setupNestErrorHandler(app, new core_1.BaseExceptionFilter(httpAdapter));
-    };
-}

package/src/lib/setup-sentry-logger.d.ts

@@ -1,6 +0,0 @@
-import { INestApplication } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-/**
- * @deprecated instead import the module SentryLoggerModule in the AppModule
- */
-export declare function SetupSentryLogger(): (app: INestApplication, config: ConfigService) => void;

package/src/lib/setup-sentry-logger.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetupSentryLogger = SetupSentryLogger;
-const nest_logger_1 = require("@rxap/nest-logger");
-const sentry_logger_1 = require("./sentry.logger");
-/**
- * @deprecated instead import the module SentryLoggerModule in the AppModule
- */
-function SetupSentryLogger() {
-    return (app, config) => {
-        if (config.get('SENTRY_ENABLED')) {
-            app.useLogger(app.get(sentry_logger_1.SentryLogger));
-        }
-        else {
-            app.useLogger(new nest_logger_1.RxapLogger());
-        }
-    };
-}