From 222d47c0680a6548033e17ef7c2451838f77393a Mon Sep 17 00:00:00 2001 From: Andrea Amorosi Date: Wed, 27 Sep 2023 10:30:45 +0200 Subject: [PATCH 1/6] feat(tracer): add try/catch logic to Tracer putMetadata --- .../tracer/src/provider/ProviderService.ts | 10 +++++++- .../tracer/tests/unit/ProviderService.test.ts | 24 +++++++++++++++++++ 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/packages/tracer/src/provider/ProviderService.ts b/packages/tracer/src/provider/ProviderService.ts index 380bdc7dd4..c3f61f8c3d 100644 --- a/packages/tracer/src/provider/ProviderService.ts +++ b/packages/tracer/src/provider/ProviderService.ts @@ -103,7 +103,15 @@ class ProviderService implements ProviderServiceInterface { return; } - segment.addMetadata(key, value, namespace); + + try { + segment.addMetadata(key, value, namespace); + } catch (error) { + console.warn( + 'Failed to add metadata to segment, catching the error to avoid stopping the execution', + error + ); + } } public setContextMissingStrategy(strategy: unknown): void { diff --git a/packages/tracer/tests/unit/ProviderService.test.ts b/packages/tracer/tests/unit/ProviderService.test.ts index 1b74701b26..f2e36171b4 100644 --- a/packages/tracer/tests/unit/ProviderService.test.ts +++ b/packages/tracer/tests/unit/ProviderService.test.ts @@ -358,5 +358,29 @@ describe('Class: ProviderService', () => { expect(segmentSpy).toHaveBeenCalledTimes(1); expect(segmentSpy).toHaveBeenCalledWith('foo', 'bar', 'baz'); }); + + test('when the underlying SDK throws an error, it catches it and logs a warning', () => { + // Prepare + const provider: ProviderService = new ProviderService(); + const segment = new Subsegment('## dummySegment'); + jest.spyOn(provider, 'getSegment').mockImplementation(() => segment); + const segmentSpy = jest + .spyOn(segment, 'addMetadata') + .mockImplementation(() => { + throw new Error('dummy error'); + }); + const logWarningSpy = jest.spyOn(console, 'warn').mockImplementation(); + + // Act + expect(() => provider.putMetadata('foo', 'bar', 'baz')).not.toThrow(); + + // Assess + expect(segmentSpy).toHaveBeenCalledTimes(1); + expect(logWarningSpy).toHaveBeenNthCalledWith( + 1, + 'Failed to add metadata to segment, catching the error to avoid stopping the execution', + new Error('dummy error') + ); + }); }); }); From a04b0aa0b14ee0fc6f28425a3acc5bfb736c0083 Mon Sep 17 00:00:00 2001 From: Andrea Amorosi Date: Wed, 27 Sep 2023 11:15:25 +0200 Subject: [PATCH 2/6] feat(tracer): add try/catch logic to Tracer middleware --- packages/tracer/src/middleware/middy.ts | 9 ++++++++- packages/tracer/src/provider/ProviderService.ts | 9 +-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/packages/tracer/src/middleware/middy.ts b/packages/tracer/src/middleware/middy.ts index 1d1a8b63f6..cc0477f01f 100644 --- a/packages/tracer/src/middleware/middy.ts +++ b/packages/tracer/src/middleware/middy.ts @@ -70,7 +70,14 @@ const captureLambdaHandler = ( if (handlerSegment === undefined || lambdaSegment === null) { return; } - handlerSegment.close(); + try { + handlerSegment.close(); + } catch (error) { + console.warn( + `Failed to close or serialize segment, ${handlerSegment.name}. We are catching the error but data might be lost.`, + error + ); + } target.setSegment(lambdaSegment); }; diff --git a/packages/tracer/src/provider/ProviderService.ts b/packages/tracer/src/provider/ProviderService.ts index c3f61f8c3d..271a820310 100644 --- a/packages/tracer/src/provider/ProviderService.ts +++ b/packages/tracer/src/provider/ProviderService.ts @@ -104,14 +104,7 @@ class ProviderService implements ProviderServiceInterface { return; } - try { - segment.addMetadata(key, value, namespace); - } catch (error) { - console.warn( - 'Failed to add metadata to segment, catching the error to avoid stopping the execution', - error - ); - } + segment.addMetadata(key, value, namespace); } public setContextMissingStrategy(strategy: unknown): void { From 1a06163cc84827cfe906ac04c8d54f05555270a6 Mon Sep 17 00:00:00 2001 From: Andrea Amorosi Date: Wed, 27 Sep 2023 11:24:23 +0200 Subject: [PATCH 3/6] feat(tracer): add try/catch logic to Tracer capture decorators --- packages/tracer/src/Tracer.ts | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/packages/tracer/src/Tracer.ts b/packages/tracer/src/Tracer.ts index c780ef6f48..dc2373749b 100644 --- a/packages/tracer/src/Tracer.ts +++ b/packages/tracer/src/Tracer.ts @@ -406,7 +406,14 @@ class Tracer extends Utility implements TracerInterface { tracerRef.addErrorAsMetadata(error as Error); throw error; } finally { - subsegment?.close(); + try { + subsegment?.close(); + } catch (error) { + console.warn( + `Failed to close or serialize segment, ${subsegment?.name}. We are catching the error but data might be lost.`, + error + ); + } subsegment?.flush(); } @@ -489,7 +496,14 @@ class Tracer extends Utility implements TracerInterface { throw error; } finally { - subsegment?.close(); + try { + subsegment?.close(); + } catch (error) { + console.warn( + `Failed to close or serialize segment, ${subsegment?.name}. We are catching the error but data might be lost.`, + error + ); + } subsegment?.flush(); } From 659a9525e0b95f7bf6ebccb4904d8ab3e5b997a7 Mon Sep 17 00:00:00 2001 From: Andrea Amorosi Date: Wed, 27 Sep 2023 12:02:05 +0200 Subject: [PATCH 4/6] chore(tracer): removed redundant flush call --- packages/tracer/src/Tracer.ts | 2 -- .../tracer/tests/unit/ProviderService.test.ts | 24 ------------------- 2 files changed, 26 deletions(-) diff --git a/packages/tracer/src/Tracer.ts b/packages/tracer/src/Tracer.ts index dc2373749b..41415facfa 100644 --- a/packages/tracer/src/Tracer.ts +++ b/packages/tracer/src/Tracer.ts @@ -414,7 +414,6 @@ class Tracer extends Utility implements TracerInterface { error ); } - subsegment?.flush(); } return result; @@ -504,7 +503,6 @@ class Tracer extends Utility implements TracerInterface { error ); } - subsegment?.flush(); } return result; diff --git a/packages/tracer/tests/unit/ProviderService.test.ts b/packages/tracer/tests/unit/ProviderService.test.ts index f2e36171b4..1b74701b26 100644 --- a/packages/tracer/tests/unit/ProviderService.test.ts +++ b/packages/tracer/tests/unit/ProviderService.test.ts @@ -358,29 +358,5 @@ describe('Class: ProviderService', () => { expect(segmentSpy).toHaveBeenCalledTimes(1); expect(segmentSpy).toHaveBeenCalledWith('foo', 'bar', 'baz'); }); - - test('when the underlying SDK throws an error, it catches it and logs a warning', () => { - // Prepare - const provider: ProviderService = new ProviderService(); - const segment = new Subsegment('## dummySegment'); - jest.spyOn(provider, 'getSegment').mockImplementation(() => segment); - const segmentSpy = jest - .spyOn(segment, 'addMetadata') - .mockImplementation(() => { - throw new Error('dummy error'); - }); - const logWarningSpy = jest.spyOn(console, 'warn').mockImplementation(); - - // Act - expect(() => provider.putMetadata('foo', 'bar', 'baz')).not.toThrow(); - - // Assess - expect(segmentSpy).toHaveBeenCalledTimes(1); - expect(logWarningSpy).toHaveBeenNthCalledWith( - 1, - 'Failed to add metadata to segment, catching the error to avoid stopping the execution', - new Error('dummy error') - ); - }); }); }); From 0df7e314578d62e63c2c676b2197ed57a739a2ee Mon Sep 17 00:00:00 2001 From: Andrea Amorosi Date: Wed, 27 Sep 2023 12:49:20 +0200 Subject: [PATCH 5/6] tests: add test cases for middleware try/catch --- packages/tracer/tests/unit/middy.test.ts | 295 +++++++++++++---------- 1 file changed, 170 insertions(+), 125 deletions(-) diff --git a/packages/tracer/tests/unit/middy.test.ts b/packages/tracer/tests/unit/middy.test.ts index 7948817baf..a292c6ef08 100644 --- a/packages/tracer/tests/unit/middy.test.ts +++ b/packages/tracer/tests/unit/middy.test.ts @@ -215,157 +215,202 @@ describe('Middy middleware', () => { delete process.env.POWERTOOLS_TRACER_CAPTURE_ERROR; }); - }); - test('when used with standard config, it captures the exception correctly', async () => { - // Prepare - const tracer: Tracer = new Tracer(); - const newSubsegment: Segment | Subsegment | undefined = new Subsegment( - '## index.handler' - ); - const setSegmentSpy = jest - .spyOn(tracer.provider, 'setSegment') - .mockImplementation(); - jest - .spyOn(tracer.provider, 'getSegment') - .mockImplementation(() => newSubsegment); - setContextMissingStrategy(() => null); - const addErrorSpy = jest.spyOn(newSubsegment, 'addError'); - const lambdaHandler: Handler = async ( - _event: unknown, - _context: Context - ) => { - throw new Error('Exception thrown!'); - }; - const handler = middy(lambdaHandler).use(captureLambdaHandler(tracer)); - - // Act & Assess - await expect( - handler({}, context, () => console.log('Lambda invoked!')) - ).rejects.toThrowError(Error); - expect(setSegmentSpy).toHaveBeenCalledTimes(2); - expect('cause' in newSubsegment).toBe(true); - expect(addErrorSpy).toHaveBeenCalledTimes(1); - expect(addErrorSpy).toHaveBeenCalledWith( - new Error('Exception thrown!'), - false - ); - expect.assertions(5); - }); + test('when used with standard config, it captures the exception correctly', async () => { + // Prepare + const tracer: Tracer = new Tracer(); + const newSubsegment: Segment | Subsegment | undefined = new Subsegment( + '## index.handler' + ); + const setSegmentSpy = jest + .spyOn(tracer.provider, 'setSegment') + .mockImplementation(); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementation(() => newSubsegment); + setContextMissingStrategy(() => null); + const addErrorSpy = jest.spyOn(newSubsegment, 'addError'); + const lambdaHandler: Handler = async ( + _event: unknown, + _context: Context + ) => { + throw new Error('Exception thrown!'); + }; + const handler = middy(lambdaHandler).use(captureLambdaHandler(tracer)); - test('when used with standard config, it annotates ColdStart correctly', async () => { - // Prepare - const tracer: Tracer = new Tracer(); - jest.spyOn(tracer.provider, 'setSegment').mockImplementation(() => ({})); - jest - .spyOn(tracer.provider, 'getSegment') - .mockImplementationOnce(() => new Segment('facade')) - .mockImplementationOnce(() => new Subsegment('## index.handler')) - .mockImplementationOnce(() => new Segment('facade')) - .mockImplementation(() => new Subsegment('## index.handler')); - const putAnnotationSpy = jest.spyOn(tracer, 'putAnnotation'); + // Act & Assess + await expect( + handler({}, context, () => console.log('Lambda invoked!')) + ).rejects.toThrowError(Error); + expect(setSegmentSpy).toHaveBeenCalledTimes(2); + expect('cause' in newSubsegment).toBe(true); + expect(addErrorSpy).toHaveBeenCalledTimes(1); + expect(addErrorSpy).toHaveBeenCalledWith( + new Error('Exception thrown!'), + false + ); + expect.assertions(5); + }); - const handler = middy(async (_event: unknown, _context: Context) => ({ - foo: 'bar', - })).use(captureLambdaHandler(tracer)); + test('when used with standard config, it annotates ColdStart correctly', async () => { + // Prepare + const tracer: Tracer = new Tracer(); + jest.spyOn(tracer.provider, 'setSegment').mockImplementation(() => ({})); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementationOnce(() => new Segment('facade')) + .mockImplementationOnce(() => new Subsegment('## index.handler')) + .mockImplementationOnce(() => new Segment('facade')) + .mockImplementation(() => new Subsegment('## index.handler')); + const putAnnotationSpy = jest.spyOn(tracer, 'putAnnotation'); - // Act - await handler({}, context); - await handler({}, context); + const handler = middy(async (_event: unknown, _context: Context) => ({ + foo: 'bar', + })).use(captureLambdaHandler(tracer)); - // Assess - // 2x Cold Start + 2x Service - expect(putAnnotationSpy).toHaveBeenCalledTimes(4); - expect(putAnnotationSpy).toHaveBeenNthCalledWith(1, 'ColdStart', true); - expect(putAnnotationSpy).toHaveBeenNthCalledWith(3, 'ColdStart', false); - }); + // Act + await handler({}, context); + await handler({}, context); - test('when used with standard config, it annotates Service correctly', async () => { - // Prepare - const tracer: Tracer = new Tracer(); - jest.spyOn(tracer.provider, 'setSegment').mockImplementation(() => ({})); - jest - .spyOn(tracer.provider, 'getSegment') - .mockImplementationOnce(() => new Segment('facade')) - .mockImplementation(() => new Subsegment('## index.handler')); - const putAnnotationSpy = jest.spyOn(tracer, 'putAnnotation'); + // Assess + // 2x Cold Start + 2x Service + expect(putAnnotationSpy).toHaveBeenCalledTimes(4); + expect(putAnnotationSpy).toHaveBeenNthCalledWith(1, 'ColdStart', true); + expect(putAnnotationSpy).toHaveBeenNthCalledWith(3, 'ColdStart', false); + }); - const handler = middy(async (_event: unknown, _context: Context) => ({ - foo: 'bar', - })).use(captureLambdaHandler(tracer)); + test('when used with standard config, it annotates Service correctly', async () => { + // Prepare + const tracer: Tracer = new Tracer(); + jest.spyOn(tracer.provider, 'setSegment').mockImplementation(() => ({})); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementationOnce(() => new Segment('facade')) + .mockImplementation(() => new Subsegment('## index.handler')); + const putAnnotationSpy = jest.spyOn(tracer, 'putAnnotation'); - // Act - await handler({}, context); + const handler = middy(async (_event: unknown, _context: Context) => ({ + foo: 'bar', + })).use(captureLambdaHandler(tracer)); - // Assess - // The first call is for the Cold Start annotation - expect(putAnnotationSpy).toHaveBeenCalledTimes(2); - expect(putAnnotationSpy).toHaveBeenNthCalledWith( - 2, - 'Service', - 'hello-world' - ); + // Act + await handler({}, context); + + // Assess + // The first call is for the Cold Start annotation + expect(putAnnotationSpy).toHaveBeenCalledTimes(2); + expect(putAnnotationSpy).toHaveBeenNthCalledWith( + 2, + 'Service', + 'hello-world' + ); + }); + + test('when enabled, and another middleware returns early, it still closes and restores the segments correctly', async () => { + // Prepare + const tracer = new Tracer(); + const setSegmentSpy = jest + .spyOn(tracer.provider, 'setSegment') + .mockImplementation(() => ({})); + jest.spyOn(tracer, 'annotateColdStart').mockImplementation(() => ({})); + jest + .spyOn(tracer, 'addServiceNameAnnotation') + .mockImplementation(() => ({})); + const facadeSegment1 = new Segment('facade'); + const handlerSubsegment1 = new Subsegment('## index.handlerA'); + jest + .spyOn(facadeSegment1, 'addNewSubsegment') + .mockImplementation(() => handlerSubsegment1); + const facadeSegment2 = new Segment('facade'); + const handlerSubsegment2 = new Subsegment('## index.handlerB'); + jest + .spyOn(facadeSegment2, 'addNewSubsegment') + .mockImplementation(() => handlerSubsegment2); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementationOnce(() => facadeSegment1) + .mockImplementationOnce(() => facadeSegment2); + const myCustomMiddleware = (): middy.MiddlewareObj => { + const before = async ( + request: middy.Request + ): Promise => { + // Return early on the second invocation + if (request.event.idx === 1) { + // Cleanup Powertools resources + await cleanupMiddlewares(request); + + // Then return early + return 'foo'; + } + }; + + return { + before, + }; + }; + const handler = middy((): void => { + console.log('Hello world!'); + }) + .use(captureLambdaHandler(tracer, { captureResponse: false })) + .use(myCustomMiddleware()); + + // Act + await handler({ idx: 0 }, context); + await handler({ idx: 1 }, context); + + // Assess + // Check that the subsegments are closed + expect(handlerSubsegment1.isClosed()).toBe(true); + expect(handlerSubsegment2.isClosed()).toBe(true); + // Check that the segments are restored + expect(setSegmentSpy).toHaveBeenCalledTimes(4); + expect(setSegmentSpy).toHaveBeenNthCalledWith(2, facadeSegment1); + expect(setSegmentSpy).toHaveBeenNthCalledWith(4, facadeSegment2); + }); }); - test('when enabled, and another middleware returns early, it still closes and restores the segments correctly', async () => { + it('catches the error and logs a warning when the segment closing/serialization fails upon closing the segment', async () => { // Prepare const tracer = new Tracer(); - const setSegmentSpy = jest - .spyOn(tracer.provider, 'setSegment') - .mockImplementation(() => ({})); + const facadeSegment = new Segment('facade'); + const handlerSubsegment = new Subsegment('## index.handler'); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementationOnce(() => facadeSegment) + .mockImplementationOnce(() => handlerSubsegment); jest.spyOn(tracer, 'annotateColdStart').mockImplementation(() => ({})); jest .spyOn(tracer, 'addServiceNameAnnotation') .mockImplementation(() => ({})); - const facadeSegment1 = new Segment('facade'); - const handlerSubsegment1 = new Subsegment('## index.handlerA'); - jest - .spyOn(facadeSegment1, 'addNewSubsegment') - .mockImplementation(() => handlerSubsegment1); - const facadeSegment2 = new Segment('facade'); - const handlerSubsegment2 = new Subsegment('## index.handlerB'); - jest - .spyOn(facadeSegment2, 'addNewSubsegment') - .mockImplementation(() => handlerSubsegment2); + const setSegmentSpy = jest + .spyOn(tracer.provider, 'setSegment') + .mockImplementation(() => ({})); jest - .spyOn(tracer.provider, 'getSegment') - .mockImplementationOnce(() => facadeSegment1) - .mockImplementationOnce(() => facadeSegment2); - const myCustomMiddleware = (): middy.MiddlewareObj => { - const before = async ( - request: middy.Request - ): Promise => { - // Return early on the second invocation - if (request.event.idx === 1) { - // Cleanup Powertools resources - await cleanupMiddlewares(request); - - // Then return early - return 'foo'; - } - }; - - return { - before, - }; - }; + .spyOn(facadeSegment, 'addNewSubsegment') + .mockImplementation(() => handlerSubsegment); const handler = middy((): void => { console.log('Hello world!'); - }) - .use(captureLambdaHandler(tracer, { captureResponse: false })) - .use(myCustomMiddleware()); + }).use(captureLambdaHandler(tracer)); + const logWarningSpy = jest.spyOn(console, 'warn'); + const closeSpy = jest + .spyOn(handlerSubsegment, 'close') + .mockImplementation(() => { + throw new Error('dummy error'); + }); // Act await handler({ idx: 0 }, context); - await handler({ idx: 1 }, context); // Assess // Check that the subsegments are closed - expect(handlerSubsegment1.isClosed()).toBe(true); - expect(handlerSubsegment2.isClosed()).toBe(true); + // expect(handlerSubsegment.close()).toHaveBeenCalled(); + expect(closeSpy).toHaveBeenCalledTimes(1); + expect(logWarningSpy).toHaveBeenNthCalledWith( + 1, + `Failed to close or serialize segment, ${handlerSubsegment.name}. We are catching the error but data might be lost.`, + new Error('dummy error') + ); // Check that the segments are restored - expect(setSegmentSpy).toHaveBeenCalledTimes(4); - expect(setSegmentSpy).toHaveBeenNthCalledWith(2, facadeSegment1); - expect(setSegmentSpy).toHaveBeenNthCalledWith(4, facadeSegment2); + expect(setSegmentSpy).toHaveBeenNthCalledWith(2, facadeSegment); }); }); From b90663249ff6f12d384db3a38e589c17282fdaf0 Mon Sep 17 00:00:00 2001 From: Andrea Amorosi Date: Wed, 27 Sep 2023 17:59:37 +0200 Subject: [PATCH 6/6] tests: add test cases for decorators try/catch --- packages/tracer/tests/unit/Tracer.test.ts | 90 +++++++++++++++++++++++ packages/tracer/tests/unit/middy.test.ts | 2 - 2 files changed, 90 insertions(+), 2 deletions(-) diff --git a/packages/tracer/tests/unit/Tracer.test.ts b/packages/tracer/tests/unit/Tracer.test.ts index 983764f65f..df6838ad13 100644 --- a/packages/tracer/tests/unit/Tracer.test.ts +++ b/packages/tracer/tests/unit/Tracer.test.ts @@ -914,6 +914,49 @@ describe('Class: Tracer', () => { otherDummyMethodSpy.mock.invocationCallOrder[0]; expect(otherDummyCallOrder).toBeLessThan(dummyCallOrder); }); + + it('catches the error and logs a warning when a segment fails to close/serialize', async () => { + // Prepare + const tracer: Tracer = new Tracer(); + const handlerSubsegment: Segment | Subsegment | undefined = + new Subsegment('### dummyMethod'); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementation(() => handlerSubsegment); + setContextMissingStrategy(() => null); + jest + .spyOn(tracer.provider, 'captureAsyncFunc') + .mockImplementation(async (methodName, callBackFn) => { + await callBackFn(handlerSubsegment); + }); + const logWarningSpy = jest.spyOn(console, 'warn'); + const closeSpy = jest + .spyOn(handlerSubsegment, 'close') + .mockImplementation(() => { + throw new Error('dummy error'); + }); + + class Lambda implements LambdaInterface { + @tracer.captureLambdaHandler() + public async handler( + _event: unknown, + _context: Context + ): Promise { + return 'foo bar'; + } + } + + // Act + await new Lambda().handler(event, context); + + // Assess + expect(closeSpy).toHaveBeenCalledTimes(1); + expect(logWarningSpy).toHaveBeenNthCalledWith( + 1, + `Failed to close or serialize segment, ${handlerSubsegment.name}. We are catching the error but data might be lost.`, + new Error('dummy error') + ); + }); }); describe('Method: captureMethod', () => { @@ -1328,6 +1371,53 @@ describe('Class: Tracer', () => { expect.anything() ); }); + + it('catches the error and logs a warning when a segment fails to close/serialize', async () => { + // Prepare + const tracer: Tracer = new Tracer(); + const handlerSubsegment: Segment | Subsegment | undefined = + new Subsegment('### dummyMethod'); + jest + .spyOn(tracer.provider, 'getSegment') + .mockImplementation(() => handlerSubsegment); + setContextMissingStrategy(() => null); + jest + .spyOn(tracer.provider, 'captureAsyncFunc') + .mockImplementation(async (methodName, callBackFn) => { + await callBackFn(handlerSubsegment); + }); + const logWarningSpy = jest.spyOn(console, 'warn'); + const closeSpy = jest + .spyOn(handlerSubsegment, 'close') + .mockImplementation(() => { + throw new Error('dummy error'); + }); + + class Lambda implements LambdaInterface { + @tracer.captureMethod() + public async dummyMethod(some: string): Promise { + return some; + } + + public async handler( + _event: unknown, + _context: Context + ): Promise { + return await this.dummyMethod('foo bar'); + } + } + + // Act + await new Lambda().handler(event, context); + + // Assess + expect(closeSpy).toHaveBeenCalledTimes(1); + expect(logWarningSpy).toHaveBeenNthCalledWith( + 1, + `Failed to close or serialize segment, ${handlerSubsegment.name}. We are catching the error but data might be lost.`, + new Error('dummy error') + ); + }); }); describe('Method: captureAWS', () => { diff --git a/packages/tracer/tests/unit/middy.test.ts b/packages/tracer/tests/unit/middy.test.ts index a292c6ef08..dc7af9d553 100644 --- a/packages/tracer/tests/unit/middy.test.ts +++ b/packages/tracer/tests/unit/middy.test.ts @@ -402,8 +402,6 @@ describe('Middy middleware', () => { await handler({ idx: 0 }, context); // Assess - // Check that the subsegments are closed - // expect(handlerSubsegment.close()).toHaveBeenCalled(); expect(closeSpy).toHaveBeenCalledTimes(1); expect(logWarningSpy).toHaveBeenNthCalledWith( 1,