Exposed addErrorAsMetadata

Author: dreamorosi

docs/core/tracer.md

@@ -95,7 +95,7 @@ You can quickly start by importing the `Tracer` class, initialize it outside the
             tracer.addResponseAsMetadata(res, context.functionName);
         } catch (err) {
             // Add the error as metadata
-            handlerSegment.addError(err as Error, false);
+            tracer.addErrorAsMetadata(err as Error);
         }
 
         // Close subsegment (the AWS Lambda one is closed automatically)

packages/tracing/README.md

@@ -80,7 +80,7 @@ export const handler = async (_event: any, context: any) => {
         tracer.addResponseAsMetadata(res, context.functionName);
     } catch (err) {
         // Add the error as metadata
-        handlerSegment.addError(err as Error, false);
+        tracer.addErrorAsMetadata(err as Error);
     }
 
     // Close subsegment (the AWS Lambda one is closed automatically)

packages/tracing/src/Tracer.ts

@@ -93,7 +93,7 @@ import { Segment, Subsegment } from 'aws-xray-sdk-core';
  *     tracer.addResponseAsMetadata(res, context.functionName);
  *   } catch (err) {
  *     // Add the error as metadata
- *     handlerSegment.addError(err as Error, false);
+ *     tracer.addErrorAsMetadata(err as Error);
  *   }
  * 
  *   // Close subsegment (the AWS Lambda one is closed automatically)
@@ -125,6 +125,28 @@ class Tracer implements TracerInterface {
     this.provider = new ProviderService();
   }
 
+  /**
+    * Add an error to the current segment or subsegment as metadata.
+    *
+    * @see https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-errors
+    *
+    * @param error - Error to serialize as metadata
+    */
+  public addErrorAsMetadata(error: Error): void {
+    if (this.tracingEnabled === false) {
+      return;
+    }
+
+    const subsegment = this.getSegment();
+    if (this.captureError === false) {
+      subsegment.addErrorFlag();
+
+      return;
+    }
+
+    subsegment.addError(error, false);
+  }
+
   /**
     * Add an data to the current segment or subsegment as metadata.
     *
@@ -385,18 +407,6 @@ class Tracer implements TracerInterface {
 
     return segment;
   }
-  
-  /**
-   * Get the current value of the `captureError` property.
-   * 
-   * You can use this method during manual instrumentation to determine
-   * if tracer should be capturing errors.
-   * 
-   * @returns captureError - `true` if errors should be captured, `false` otherwise. 
-   */
-  public isCaptureErrorEnabled(): boolean {
-    return this.captureError;
-  }
 
   /**
    * Retrieve the current value of `ColdStart`.
@@ -522,25 +532,6 @@ class Tracer implements TracerInterface {
   public setSegment(segment: Segment | Subsegment): void {
     return this.provider.setSegment(segment);
   }
-
-  /**
-    * Add an error to the current segment or subsegment as metadata.
-    * Used internally by decoratorators and middlewares.
-    *
-    * @see https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-errors
-    *
-    * @param error - Error to serialize as metadata
-    */
-  private addErrorAsMetadata(error: Error): void {
-    const subsegment = this.getSegment();
-    if (this.captureError === false) {
-      subsegment.addErrorFlag();
-
-      return;
-    }
-
-    subsegment.addError(error, false);
-  }
 
   /**
    * Add ColdStart annotation to the current segment or subsegment.

packages/tracing/src/middleware/middy.ts

@@ -49,11 +49,8 @@ const captureLambdaHandler = (target: Tracer): middy.MiddlewareObj => {
   const captureLambdaHandlerError = async (request: middy.Request): Promise<void> => {
     if (target.isTracingEnabled()) {
       const subsegment = target.getSegment();
-      if (target.isCaptureErrorEnabled() === false) {  
-        subsegment?.addErrorFlag();
-      } else {
-        subsegment?.addError(request.error as Error, false);
-      }
+      target.addErrorAsMetadata(request.error as Error);
+
       // TODO: should this error be thrown?? I.e. should we stop the event flow & return?
       // throw request.error;
 

packages/tracing/tests/unit/Tracer.test.ts

@@ -87,6 +87,63 @@ describe('Class: Tracer', () => {
 
   });
 
+  describe('Method: addErrorAsMetadata', () => {
+
+    test('when called while tracing is disabled, it does nothing', () => {
+
+      // Prepare
+      const tracer: Tracer = new Tracer({ enabled: false });
+      const getSegmentSpy = jest.spyOn(tracer, 'getSegment');
+
+      // Act
+      tracer.addErrorAsMetadata(new Error('foo'));
+
+      // Assess
+      expect(getSegmentSpy).toBeCalledTimes(0);
+
+    });
+
+    test('when called while POWERTOOLS_TRACER_CAPTURE_ERROR is set to false, it does not capture the error', () => {
+
+      // Prepare
+      process.env.POWERTOOLS_TRACER_CAPTURE_ERROR = 'false';
+      const tracer: Tracer = new Tracer();
+      const subsegment = new Subsegment(`## ${context.functionName}`);
+      jest.spyOn(tracer, 'getSegment').mockImplementation(() => subsegment);
+      const addErrorFlagSpy = jest.spyOn(subsegment, 'addErrorFlag');
+      const addErrorSpy = jest.spyOn(subsegment, 'addError');
+
+      // Act
+      tracer.addErrorAsMetadata(new Error('foo'));
+
+      // Assess
+      expect(addErrorFlagSpy).toBeCalledTimes(1);
+      expect(addErrorSpy).toBeCalledTimes(0);
+      delete process.env.POWERTOOLS_TRACER_CAPTURE_ERROR;
+
+    });
+
+    test('when called with default config, it calls subsegment.addError correctly', () => {
+
+      // Prepare
+      const tracer: Tracer = new Tracer();
+      const subsegment = new Subsegment(`## ${context.functionName}`);
+      jest.spyOn(tracer, 'getSegment').mockImplementation(() => subsegment);
+      const addErrorFlagSpy = jest.spyOn(subsegment, 'addErrorFlag');
+      const addErrorSpy = jest.spyOn(subsegment, 'addError');
+
+      // Act
+      tracer.addErrorAsMetadata(new Error('foo'));
+
+      // Assess
+      expect(addErrorFlagSpy).toBeCalledTimes(0);
+      expect(addErrorSpy).toBeCalledTimes(1);
+      expect(addErrorSpy).toBeCalledWith(new Error('foo'), false);
+
+    });
+
+  });
+
   describe('Method: isColdStart', () => {
 
     test('when called, it returns false the first time and always true after that', () => {