chore: remove the captureError option

Author: misterjoshua

Diff for: docs/core/tracer.md

@@ -454,40 +454,6 @@ Use **`POWERTOOLS_TRACER_CAPTURE_ERROR=false`** environment variable to instruct
 
     1. You might **return sensitive** information from exceptions, stack traces you might not control
 
-### Disabling exception capture for targeted methods and handlers
-
-Use the `captureError: false` option in both `tracer.captureLambdaHandler()` and `tracer.captureMethod()` decorators to instruct Tracer **not** to serialize exceptions as metadata.
-
-=== "method.ts"
-
-    ```typescript hl_lines="5"
-    import { Tracer } from '@aws-lambda-powertools/tracer';
-
-    const tracer = new Tracer({ serviceName: 'serverlessAirline' });
-    class MyThing {
-        @tracer.captureMethod({ captureError: false })
-        myMethod(): string {
-            /* ... */
-            return 'foo bar';
-        }
-    }
-    ```
-
-=== "handler.ts"
-
-    ```typescript hl_lines="6"
-    import { Tracer } from '@aws-lambda-powertools/tracer';
-    import { LambdaInterface } from '@aws-lambda-powertools/commons';
-
-    const tracer = new Tracer({ serviceName: 'serverlessAirline' });
-    class MyHandler implements LambdaInterface {
-        @tracer.captureLambdaHandler({ captureError: false })
-        async handler(_event: any, _context: any): Promise<void> {
-            /* ... */
-        }
-    }
-    ```
-
 ### Escape hatch mechanism
 
 You can use `tracer.provider` attribute to access all methods provided by the [AWS X-Ray SDK](https://docs.aws.amazon.com/xray-sdk-for-nodejs/latest/reference/AWSXRay.html).

Diff for: packages/tracer/src/Tracer.ts

@@ -370,13 +370,7 @@ class Tracer extends Utility implements TracerInterface {
             }
 
           } catch (error) {
-            if (options?.captureError ?? true) {
-              tracerRef.addErrorAsMetadata(error as Error);
-            } else {
-              // Though we aren't adding the error as metadata, we should still
-              // mark the segment as having an error.
-              tracerRef.getSegment().addErrorFlag();
-            }
+            tracerRef.addErrorAsMetadata(error as Error);
             throw error;
           } finally {
             subsegment?.close();
@@ -449,14 +443,7 @@ class Tracer extends Utility implements TracerInterface {
             }
 
           } catch (error) {
-            if (options?.captureError ?? true) {
-              tracerRef.addErrorAsMetadata(error as Error);
-            } else {
-              // Though we aren't adding the error as metadata, we should still
-              // mark the segment as having an error.
-              tracerRef.getSegment().addErrorFlag();
-            }
-            
+            tracerRef.addErrorAsMetadata(error as Error);
             throw error;
           } finally {
             subsegment?.close();

Diff for: packages/tracer/src/types/Tracer.ts

@@ -35,7 +35,7 @@ type TracerOptions = {
  * const tracer = new Tracer();
  *
  * class MyThing {
- *   @tracer.captureMethod({ captureResponse: false, captureError: false })
+ *   @tracer.captureMethod({ captureResponse: false })
  *   myMethod(): string {
  *     return 'foo bar';
  *   }
@@ -44,7 +44,6 @@ type TracerOptions = {
  */
 type TracerCaptureMethodOptions = {
   captureResponse?: boolean
-  captureError?: boolean
 };
 
 /**
@@ -56,14 +55,13 @@ type TracerCaptureMethodOptions = {
  * const tracer = new Tracer();
  *
  * class MyThing implements LambdaInterface {
- *   @tracer.captureLambdaHandler({ captureResponse: false, captureError: false })
+ *   @tracer.captureLambdaHandler({ captureResponse: false })
  *   async handler(_event: any, _context: any): Promise<void> {}
  * }
  * ```
  */
 type TracerCaptureLambdaHandlerOptions = {
   captureResponse?: boolean
-  captureError?: boolean
 };
 
 type HandlerMethodDecorator = (

Diff for: packages/tracer/tests/unit/Tracer.test.ts

@@ -757,41 +757,6 @@ describe('Class: Tracer', () => {
 
     });
 
-    test('when used as decorator while captureError is set to false, it does not capture the exceptions', async () => {
-
-      // Prepare
-      const tracer: Tracer = new Tracer();
-      const newSubsegment: Segment | Subsegment | undefined = new Subsegment('## index.handler');
-      jest.spyOn(tracer.provider, 'getSegment')
-        .mockImplementation(() => newSubsegment);
-      setContextMissingStrategy(() => null);
-      const captureAsyncFuncSpy = jest.spyOn(tracer.provider, 'captureAsyncFunc');
-      const addErrorSpy = jest.spyOn(newSubsegment, 'addError');
-      const addErrorFlagSpy = jest.spyOn(newSubsegment, 'addErrorFlag');
-      class Lambda implements LambdaInterface {
-
-        @tracer.captureLambdaHandler({ captureError: false })
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        public handler<TEvent, TResult>(_event: TEvent, _context: Context, _callback: Callback<TResult>): void | Promise<TResult> {
-          throw new Error('Exception thrown!');
-        }
-
-      }
-
-      // Act & Assess
-      await expect(new Lambda().handler({}, context, () => console.log('Lambda invoked!'))).rejects.toThrowError(Error);
-      expect(captureAsyncFuncSpy).toHaveBeenCalledTimes(1);
-      expect(newSubsegment).toEqual(expect.objectContaining({
-        name: '## index.handler',
-      }));
-      expect('cause' in newSubsegment).toBe(false);
-      expect(addErrorFlagSpy).toHaveBeenCalledTimes(1);
-      expect(addErrorSpy).toHaveBeenCalledTimes(0);
-      expect.assertions(6);
-
-    });
-
     test('when used as decorator and with standard config, it captures the exception correctly', async () => {
 
       // Prepare
@@ -1115,47 +1080,6 @@ describe('Class: Tracer', () => {
 
     });
 
-    test('when used as decorator and with captureError set to false, it does not capture the exception', async () => {
-
-      // Prepare
-      const tracer: Tracer = new Tracer();
-      const newSubsegment: Segment | Subsegment | undefined = new Subsegment('### dummyMethod');
-      jest.spyOn(tracer.provider, 'getSegment')
-        .mockImplementation(() => newSubsegment);
-      setContextMissingStrategy(() => null);
-      const captureAsyncFuncSpy = createCaptureAsyncFuncMock(tracer.provider);
-      const addErrorSpy = jest.spyOn(newSubsegment, 'addError');
-      const addErrorFlagSpy = jest.spyOn(newSubsegment, 'addErrorFlag');
-      class Lambda implements LambdaInterface {
-
-        @tracer.captureMethod({ captureError: false })
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        public async dummyMethod(_some: string): Promise<string> {
-          throw new Error('Exception thrown!');
-        }
-
-        public async handler<TEvent, TResult>(_event: TEvent, _context: Context, _callback: Callback<TResult>): Promise<TResult> {
-          const result = await this.dummyMethod('foo bar');
-
-          return new Promise((resolve, _reject) => resolve(result as unknown as TResult));
-        }
-
-      }
-
-      // Act / Assess
-      await expect(new Lambda().handler({}, context, () => console.log('Lambda invoked!'))).rejects.toThrowError(Error);
-      expect(captureAsyncFuncSpy).toHaveBeenCalledTimes(1);
-      expect(newSubsegment).toEqual(expect.objectContaining({
-        name: '### dummyMethod',
-      }));
-      expect('cause' in newSubsegment).toBe(false);
-      expect(addErrorFlagSpy).toHaveBeenCalledTimes(1);
-      expect(addErrorSpy).toHaveBeenCalledTimes(0);
-      expect.assertions(6);
-
-    });
-
     test('when used as decorator and when calling other methods/props in the class they are called in the orginal scope', async () => {
 
       // Prepare