test: updated e2e tracing

Author: dreamorosi

packages/tracing/tests/e2e/tracer.test.ts

@@ -109,7 +109,7 @@ describe('Tracer integration tests', () => {
     });
 
     // sleep to allow for traces to be collected
-    await new Promise((resolve) => setTimeout(resolve, 200000));
+    await new Promise((resolve) => setTimeout(resolve, 180000));
 
   }, 360000); // 6 minutes
 
@@ -460,6 +460,103 @@ describe('Tracer integration tests', () => {
 
   }, 120000); // 2 minutes
 
+  it('Verifies that a when Tracer is used as decorator on an async handler all custom traces are generated with correct annotations and metadata', async () => {
+    
+    const resourceArn = invocationsMap['DecoratorWithAsyncHandler'].resourceArn;
+    const expectedServiceName = invocationsMap['DecoratorWithAsyncHandler'].serviceName;
+    
+    // Assess
+    // Retrieve traces from X-Ray using Resource ARN as filter
+    const sortedTraces = await getTraces(xray, startTime, resourceArn, invocations);
+
+    for (let i = 0; i < invocations; i++) {
+      // Assert that the trace has the expected amount of segments
+      expect(sortedTraces[i].Segments.length).toBe(4);
+
+      const invocationSubsegment = getInvocationSubsegment(sortedTraces[i]);
+
+      if (invocationSubsegment?.subsegments !== undefined) {
+        expect(invocationSubsegment?.subsegments?.length).toBe(1);
+        const handlerSubsegment = invocationSubsegment?.subsegments[0];
+        // Assert that the subsegment name is the expected one
+        expect(handlerSubsegment.name).toBe('## index.handler');
+        if (handlerSubsegment?.subsegments !== undefined) {
+          // Assert that there're three subsegments
+          expect(handlerSubsegment?.subsegments?.length).toBe(3);
+          
+          // Sort the subsegments by name
+          const stsSubsegments: ParsedDocument[] = [];
+          const methodSubsegment: ParsedDocument[] = [];
+          const otherSegments: ParsedDocument[] = [];
+          handlerSubsegment?.subsegments.forEach(subsegment => {
+            if (subsegment.name === 'STS') {
+              stsSubsegments.push(subsegment);
+            } else if (subsegment.name === '### myMethod') {
+              methodSubsegment.push(subsegment);
+            } else {
+              otherSegments.push(subsegment);
+            }
+          });
+          // Assert that there are exactly two subsegment with the name 'STS'
+          expect(stsSubsegments.length).toBe(2);
+          // Assert that there is exactly one subsegment with the name '### myMethod'
+          expect(methodSubsegment.length).toBe(1);
+          // Assert that there are exactly zero other subsegments
+          expect(otherSegments.length).toBe(0);
+
+          const { metadata } = methodSubsegment[0];
+
+          if (metadata !== undefined) {
+            // Assert that the metadata object is as expected
+            expect(metadata[expectedServiceName]['myMethod response'])
+              .toEqual(expectedCustomResponseValue);
+          } else {
+            // Make test fail if there is no metadata
+            expect('metadata !== undefined')
+              .toBe('metadata === undefined');
+          }
+        } else {
+          // Make test fail if the handlerSubsegment subsegment doesn't have any subsebment
+          expect('handlerSubsegment?.subsegments !== undefined')
+            .toBe('handlerSubsegment?.subsegments === undefined');
+        }
+        
+        const { annotations, metadata } = handlerSubsegment;
+
+        if (annotations !== undefined && metadata !== undefined) {
+          // Assert that the annotations are as expected
+          expect(annotations['ColdStart']).toEqual(true ? i === 0 : false);
+          expect(annotations['Service']).toEqual(expectedServiceName);
+          expect(annotations[expectedCustomAnnotationKey]).toEqual(expectedCustomAnnotationValue);
+          // Assert that the metadata object is as expected
+          expect(metadata[expectedServiceName][expectedCustomMetadataKey])
+            .toEqual(expectedCustomMetadataValue);
+          
+          if (i === invocations - 1) {
+            // Assert that the subsegment has the expected fault
+            expect(invocationSubsegment.error).toBe(true);
+            expect(handlerSubsegment.fault).toBe(true);
+            expect(handlerSubsegment.hasOwnProperty('cause')).toBe(true);
+            expect(handlerSubsegment.cause?.exceptions[0].message).toBe(expectedCustomErrorMessage);
+          } else {
+            // Assert that the metadata object contains the response
+            expect(metadata[expectedServiceName]['index.handler response'])
+              .toEqual(expectedCustomResponseValue);
+          }
+        } else {
+          // Make test fail if there are no annotations or metadata
+          expect('annotations !== undefined && metadata !== undefined')
+            .toBe('annotations === undefined && metadata === undefined');
+        }
+      } else {
+        // Make test fail if the Invocation subsegment doesn't have an handler subsebment
+        expect('invocationSubsegment?.subsegments !== undefined')
+          .toBe('invocationSubsegment?.subsegments === undefined');
+      }
+    }
+
+  }, 120000); // 2 minutes
+
   it('Verifies that a when Tracer is used as decorator, with errors & response capturing disabled, all custom traces are generated with correct annotations', async () => {
 
     const resourceArn = invocationsMap['Decorator-NoCaptureErrorResponse'].resourceArn;