chore: fix merge conflicts

Author: dreamorosi

packages/tracer/src/Tracer.ts

@@ -420,7 +420,7 @@ class Tracer extends Utility implements TracerInterface {
    * @decorator Class
    */
   public captureMethod(options?: HandlerOptions): MethodDecorator {
-    return (_target, _propertyKey, descriptor) => {
+    return (_target, propertyKey, descriptor) => {
       // The descriptor.value is the method this decorator decorates, it cannot be undefined.
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const originalMethod = descriptor.value!;
@@ -434,12 +434,14 @@ class Tracer extends Utility implements TracerInterface {
           return originalMethod.apply(this, [...args]);
         }
 
-        return tracerRef.provider.captureAsyncFunc(`### ${originalMethod.name}`, async subsegment => {
+        const methodName = String(propertyKey);
+
+        return tracerRef.provider.captureAsyncFunc(`### ${methodName}`, async subsegment => {
           let result;
           try {
             result = await originalMethod.apply(this, [...args]);
             if (options?.captureResponse ?? true) {
-              tracerRef.addResponseAsMetadata(result, originalMethod.name);
+              tracerRef.addResponseAsMetadata(result, methodName);
             }
           } catch (error) {
             tracerRef.addErrorAsMetadata(error as Error);

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

@@ -1294,7 +1294,7 @@ describe('Class: Tracer', () => {
       // Prepare
       const tracer: Tracer = new Tracer();
       const newSubsegment: Segment | Subsegment | undefined = new Subsegment('### dummyMethod');
-      
+
       jest.spyOn(tracer.provider, 'getSegment')
         .mockImplementation(() => newSubsegment);
       setContextMissingStrategy(() => null);
@@ -1319,23 +1319,82 @@ describe('Class: Tracer', () => {
         public otherDummyMethod(): void {
           return;
         }
-
       }
-      
+
       // Act
       const lambda = new Lambda();
       const otherDummyMethodSpy = jest.spyOn(lambda, 'otherDummyMethod').mockImplementation();
       const handler = lambda.handler.bind(lambda);
       await handler({}, context, () => console.log('Lambda invoked!'));
-
-      // Assess
+      
       // Here we assert that the subsegment.close() (inside the finally of decorator) is called before the other otherDummyMethodSpy method
       // that should always be called after the handler has returned. If subsegment.close() is called after it means the
       // decorator is NOT awaiting the method which would cause the test to fail.
       expect(subsegmentCloseSpy.mock.invocationCallOrder[0]).toBeLessThan(otherDummyMethodSpy.mock.invocationCallOrder[0]);
 
     });
 
+    test('when used as decorator together with another external decorator, the method name is detected properly', async () => {
+
+      // Prepare
+      const tracer: Tracer = new Tracer();
+      const newSubsegment: Segment | Subsegment | undefined = new Subsegment('### dummyMethod');
+      jest.spyOn(tracer.provider, 'getSegment')
+        .mockImplementation(() => newSubsegment);
+      setContextMissingStrategy(() => null);
+      createCaptureAsyncFuncMock(tracer.provider, newSubsegment);
+
+      // Creating custom external decorator
+      // eslint-disable-next-line func-style
+      function passThrough() {
+        // A decorator that calls the original method.
+        return (
+          _target: unknown,
+          _propertyKey: string,
+          descriptor: PropertyDescriptor
+        ) => {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          const originalMethod = descriptor.value!;
+          descriptor.value = function (...args: unknown[]) {
+            return originalMethod.apply(this, [...args]);
+          };
+        };
+      }
+
+      class Lambda implements LambdaInterface {
+        @tracer.captureMethod()
+        @passThrough()
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        public async dummyMethod(): Promise<string> {
+          return `foo`;
+        }
+
+        public async handler<TEvent, TResult>(_event: TEvent, _context: Context, _callback: Callback<TResult>): Promise<void> {
+          await this.dummyMethod();
+
+          return;
+        }
+
+      }
+
+      // Act / Assess
+      const lambda = new Lambda();
+      const handler = lambda.handler.bind(lambda);
+      await handler({}, context, () => console.log('Lambda invoked!'));
+
+      // Assess
+      expect(newSubsegment).toEqual(expect.objectContaining({
+        metadata: {
+          'hello-world': {
+            // Assess that the method name is added correctly
+            'dummyMethod response': 'foo',
+          },
+        }
+      }));
+
+    });
+
   });
 
   describe('Method: captureAWS', () => {