fix: Runtime Error for nested sync fns #32

Author: heitorlessa

Diff for: python/aws_lambda_powertools/tracing/tracer.py

@@ -270,7 +270,7 @@ def decorate(event, context):
                             key="lambda handler response", value=response, namespace=self._config["service"]
                         )
                 except Exception as err:
-                    logger.exception("Exception received from lambda handler", exc_info=True)
+                    logger.exception("Exception received from lambda handler")
                     subsegment.put_metadata(key=f"{self.service} error", value=err, namespace=self._config["service"])
                     raise
 
@@ -392,68 +392,40 @@ async def async_tasks():
         """
         method_name = f"{method.__name__}"
 
-        async def decorate_logic(
-            decorated_method_with_args: functools.partial = None,
-            subsegment: aws_xray_sdk.core.models.subsegment = None,
-            coroutine: bool = False,
-        ) -> Any:
-            """Decorate logic runs both sync and async decorated methods
-
-            Parameters
-            ----------
-            decorated_method_with_args : functools.partial
-                Partial decorated method with arguments/keyword arguments
-            subsegment : aws_xray_sdk.core.models.subsegment
-                X-Ray subsegment to reuse
-            coroutine : bool, optional
-                Instruct whether partial decorated method is a wrapped coroutine, by default False
-
-            Returns
-            -------
-            Any
-                Returns method's response
-            """
-            response = None
-            try:
-                logger.debug(f"Calling method: {method_name}")
-                if coroutine:
-                    response = await decorated_method_with_args()
-                else:
-                    response = decorated_method_with_args()
-                    logger.debug(f"Received {method_name} response successfully")
-                    logger.debug(response)
-            except Exception as err:
-                logger.exception(f"Exception received from '{method_name}' method", exc_info=True)
-                subsegment.put_metadata(key=f"{method_name} error", value=err, namespace=self._config["service"])
-                raise
-            finally:
-                if response is not None:
-                    subsegment.put_metadata(  # pragma: no cover
-                        key=f"{method_name} response", value=response, namespace=self._config["service"]
-                    )
-
-            return response
-
         if inspect.iscoroutinefunction(method):
-
             @functools.wraps(method)
             async def decorate(*args, **kwargs):
-                decorated_method_with_args = functools.partial(method, *args, **kwargs)
-                async with self.provider.in_subsegment_async(name=f"## {method_name}") as subsegment:
-                    return await decorate_logic(
-                        decorated_method_with_args=decorated_method_with_args, subsegment=subsegment, coroutine=True
-                    )
-
+                async with self.provider.in_subsegment_async(name=f"## {method_name}") as subsegment:                    
+                    try:
+                        logger.debug(f"Calling method: {method_name}")
+                        response = await method(*args, **kwargs)
+                        if response is not None:
+                            subsegment.put_metadata(  # pragma: no cover
+                                key=f"{method_name} response", value=response, namespace=self._config["service"]
+                            )
+                    except Exception as err:
+                        logger.exception(f"Exception received from '{method_name}' method")
+                        subsegment.put_metadata(key=f"{method_name} error", value=err, namespace=self._config["service"])
+                        raise
+
+                    return response
         else:
-
             @functools.wraps(method)
             def decorate(*args, **kwargs):
-                loop = asyncio.get_event_loop()
-                decorated_method_with_args = functools.partial(method, *args, **kwargs)
                 with self.provider.in_subsegment(name=f"## {method_name}") as subsegment:
-                    return loop.run_until_complete(
-                        decorate_logic(decorated_method_with_args=decorated_method_with_args, subsegment=subsegment)
-                    )
+                    try:
+                        logger.debug(f"Calling method: {method_name}")
+                        response = method(*args, **kwargs)
+                        if response is not None:
+                            subsegment.put_metadata(  # pragma: no cover
+                                key=f"{method_name} response", value=response, namespace=self._config["service"]
+                            )
+                    except Exception as err:
+                        logger.exception(f"Exception received from '{method_name}' method")
+                        subsegment.put_metadata(key=f"{method_name} error", value=err, namespace=self._config["service"])
+                        raise
+
+                    return response
 
         return decorate
 

Diff for: python/tests/functional/test_tracing.py

@@ -124,3 +124,23 @@ def test_tracer_reuse():
 
     assert id(tracer_a) != id(tracer_b)
     assert tracer_a.__dict__.items() == tracer_b.__dict__.items()
+
+def test_tracer_method_nested_sync(mocker):
+    # GIVEN tracer is disabled, decorator is used
+    # WHEN multiple sync functions are nested
+    # THEN tracer should not raise a Runtime Error
+    tracer = Tracer(disabled=True)
+
+    @tracer.capture_method
+    def func_1():
+        return 1
+
+    @tracer.capture_method
+    def func_2():
+        return 2
+
+    @tracer.capture_method
+    def sums_values():
+        return func_1() + func_2()
+
+    sums_values()