Merge pull request #61 from TeamHive/fix/remove-sanitize-error

Fix/remove sanitize error

Author: tvmaasjazz

src/modules/exceptions/base.exception.ts

@@ -5,6 +5,10 @@ export class BaseException extends HttpException {
         [key: string]: any;
     };
 
+    tags: {
+        [key: string]: number | string | boolean | bigint | symbol | null | undefined;
+    };
+
     error: Error;
 
     loggedMetadata: any;

src/modules/services/error-handler/error-handler.service.ts

@@ -2,7 +2,6 @@ import { Inject, Injectable, Optional } from '@nestjs/common';
 import { StaticErrorHandlerConfiguration, StaticErrorHandlerService } from '@teamhive/node-common';
 import { Logger } from 'log4js';
 import { ApplicationTokens } from '../../application-tokens.const';
-import { BaseException } from '../../exceptions';
 import { Breadcrum } from '../../interfaces/breadcrum.interface';
 import { ErrorHandlerConfigurationToken } from '../../providers/error-handler-configuration/error-handler-configuration.provider';
 @Injectable()
@@ -32,65 +31,10 @@ export class ErrorHandler {
     }
 
     captureException(error: Error) {
-        StaticErrorHandlerService.captureException(this.sanitizeError(error), this.logger, this.errorHandlerConfiguration);
+        StaticErrorHandlerService.captureException(error, this.logger, this.errorHandlerConfiguration);
     }
 
     captureMessage(message: string) {
         StaticErrorHandlerService.captureMessage(message, this.logger);
     }
-
-    sanitizeError(error: Error) {
-        const sanitizeException = this.errorHandlerConfiguration.sanitizeException ?? true;
-        if (!sanitizeException) {
-            return error;
-        }
-        let name: string;
-        let message: string;
-        let stack: string;
-        let loggedMetadata: any;
-        let prototype: any;
-        if (error instanceof BaseException) {
-            const exception = error;
-            const subError = exception.error;
-            if (subError) {
-                name = subError.name !== 'Error' ? subError.name : undefined;
-                stack = subError.stack;
-                message = subError.message;
-            }
-            if (!name) {
-                name = exception.name !== 'Error' ? exception.name : undefined;
-            }
-            if (!stack) {
-                stack = exception.stack;
-            }
-            if (!message) {
-                message = exception.message;
-            }
-            prototype = Object.getPrototypeOf(exception);
-            loggedMetadata = exception.loggedMetadata;
-        }
-        else {
-            name = error.name;
-            message = error.message;
-            stack = error.stack;
-            prototype = Object.getPrototypeOf(error);
-        }
-        const sanitizedError = new Error(message);
-        sanitizedError.stack = stack;
-        sanitizedError.message = message;
-        (sanitizedError as any).loggedMetadata = loggedMetadata;
-        (sanitizedError as any).__proto__ = prototype;
-
-        // if there isn't a specific name given, clear the name so the constructor name is used
-        if (name) {
-            sanitizedError.name = name;
-        }
-        else {
-            // clear the name on the object
-            sanitizedError.name = undefined;
-            // remove the key from the error
-            delete sanitizedError.name;
-        }
-        return sanitizedError;
-    }
 }