Merge branch 'develop' into pydantic

Author: ran-isenberg

CHANGELOG.md

@@ -6,6 +6,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.1] - 2020-08-22
+### Fixed
+- **Tracer**: capture_method decorator did not properly handle nested context managers
+
+## [1.3.0] - 2020-08-21
+### Added
+- **Utilities**: Add new `parameters` utility to retrieve a single or multiple parameters from SSM Parameter Store, Secrets Manager, DynamoDB, or your very own
+
+## [1.2.0] - 2020-08-20
+### Added
+- **Tracer**: capture_method decorator now supports generator functions (including context managers)
+
 ## [1.1.3] - 2020-08-18
 ### Fixed
 - **Logger**: Logs emitted twice, structured and unstructured, due to Lambda configuring the root handler

aws_lambda_powertools/tracing/tracer.py

@@ -1,3 +1,4 @@
+import contextlib
 import copy
 import functools
 import inspect
@@ -320,6 +321,39 @@ def lambda_handler(event: dict, context: Any) -> Dict:
                 booking_id = event.get("booking_id")
                 asyncio.run(confirm_booking(booking_id=booking_id))
 
+        **Custom generator function using capture_method decorator**
+
+            from aws_lambda_powertools import Tracer
+            tracer = Tracer(service="booking")
+
+            @tracer.capture_method
+            def bookings_generator(booking_id):
+                resp = call_to_booking_service()
+                yield resp[0]
+                yield resp[1]
+
+            def lambda_handler(event: dict, context: Any) -> Dict:
+                gen = bookings_generator(booking_id=booking_id)
+                result = list(gen)
+
+        **Custom generator context manager using capture_method decorator**
+
+            from aws_lambda_powertools import Tracer
+            tracer = Tracer(service="booking")
+
+            @tracer.capture_method
+            @contextlib.contextmanager
+            def booking_actions(booking_id):
+                resp = call_to_booking_service()
+                yield "example result"
+                cleanup_stuff()
+
+            def lambda_handler(event: dict, context: Any) -> Dict:
+                booking_id = event.get("booking_id")
+
+                with booking_actions(booking_id=booking_id) as booking:
+                    result = booking
+
         **Tracing nested async calls**
 
             from aws_lambda_powertools import Tracer
@@ -392,43 +426,92 @@ async def async_tasks():
         err
             Exception raised by method
         """
-        method_name = f"{method.__name__}"
 
         if inspect.iscoroutinefunction(method):
+            decorate = self._decorate_async_function(method=method)
+        elif inspect.isgeneratorfunction(method):
+            decorate = self._decorate_generator_function(method=method)
+        elif hasattr(method, "__wrapped__") and inspect.isgeneratorfunction(method.__wrapped__):
+            decorate = self._decorate_generator_function_with_context_manager(method=method)
+        else:
+            decorate = self._decorate_sync_function(method=method)
 
-            @functools.wraps(method)
-            async def decorate(*args, **kwargs):
-                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)
-                        self._add_response_as_metadata(function_name=method_name, data=response, subsegment=subsegment)
-                    except Exception as err:
-                        logger.exception(f"Exception received from '{method_name}' method")
-                        self._add_full_exception_as_metadata(
-                            function_name=method_name, error=err, subsegment=subsegment
-                        )
-                        raise
-
-                    return response
+        return decorate
 
-        else:
+    def _decorate_async_function(self, method: Callable = None):
+        method_name = f"{method.__name__}"
+
+        @functools.wraps(method)
+        async def decorate(*args, **kwargs):
+            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)
+                    self._add_response_as_metadata(function_name=method_name, data=response, subsegment=subsegment)
+                except Exception as err:
+                    logger.exception(f"Exception received from '{method_name}' method")
+                    self._add_full_exception_as_metadata(function_name=method_name, error=err, subsegment=subsegment)
+                    raise
 
-            @functools.wraps(method)
-            def decorate(*args, **kwargs):
-                with self.provider.in_subsegment(name=f"## {method_name}") as subsegment:
-                    try:
-                        logger.debug(f"Calling method: {method_name}")
-                        response = method(*args, **kwargs)
-                        self._add_response_as_metadata(function_name=method_name, data=response, subsegment=subsegment)
-                    except Exception as err:
-                        logger.exception(f"Exception received from '{method_name}' method")
-                        self._add_full_exception_as_metadata(
-                            function_name=method_name, error=err, subsegment=subsegment
-                        )
-                        raise
-
-                    return response
+                return response
+
+        return decorate
+
+    def _decorate_generator_function(self, method: Callable = None):
+        method_name = f"{method.__name__}"
+
+        @functools.wraps(method)
+        def decorate(*args, **kwargs):
+            with self.provider.in_subsegment(name=f"## {method_name}") as subsegment:
+                try:
+                    logger.debug(f"Calling method: {method_name}")
+                    result = yield from method(*args, **kwargs)
+                    self._add_response_as_metadata(function_name=method_name, data=result, subsegment=subsegment)
+                except Exception as err:
+                    logger.exception(f"Exception received from '{method_name}' method")
+                    self._add_full_exception_as_metadata(function_name=method_name, error=err, subsegment=subsegment)
+                    raise
+
+                return result
+
+        return decorate
+
+    def _decorate_generator_function_with_context_manager(self, method: Callable = None):
+        method_name = f"{method.__name__}"
+
+        @functools.wraps(method)
+        @contextlib.contextmanager
+        def decorate(*args, **kwargs):
+            with self.provider.in_subsegment(name=f"## {method_name}") as subsegment:
+                try:
+                    logger.debug(f"Calling method: {method_name}")
+                    with method(*args, **kwargs) as return_val:
+                        result = return_val
+                        yield result
+                    self._add_response_as_metadata(function_name=method_name, data=result, subsegment=subsegment)
+                except Exception as err:
+                    logger.exception(f"Exception received from '{method_name}' method")
+                    self._add_full_exception_as_metadata(function_name=method_name, error=err, subsegment=subsegment)
+                    raise
+
+        return decorate
+
+    def _decorate_sync_function(self, method: Callable = None):
+        method_name = f"{method.__name__}"
+
+        @functools.wraps(method)
+        def decorate(*args, **kwargs):
+            with self.provider.in_subsegment(name=f"## {method_name}") as subsegment:
+                try:
+                    logger.debug(f"Calling method: {method_name}")
+                    response = method(*args, **kwargs)
+                    self._add_response_as_metadata(function_name=method_name, data=response, subsegment=subsegment)
+                except Exception as err:
+                    logger.exception(f"Exception received from '{method_name}' method")
+                    self._add_full_exception_as_metadata(function_name=method_name, error=err, subsegment=subsegment)
+                    raise
+
+                return response
 
         return decorate
 

aws_lambda_powertools/utilities/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+"""General utilities for Powertools"""

aws_lambda_powertools/utilities/parameters/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+"""
+Parameter retrieval and caching utility
+"""
+
+from .base import BaseProvider
+from .dynamodb import DynamoDBProvider
+from .exceptions import GetParameterError, TransformParameterError
+from .secrets import SecretsProvider, get_secret
+from .ssm import SSMProvider, get_parameter, get_parameters
+
+__all__ = [
+    "BaseProvider",
+    "GetParameterError",
+    "DynamoDBProvider",
+    "SecretsProvider",
+    "SSMProvider",
+    "TransformParameterError",
+    "get_parameter",
+    "get_parameters",
+    "get_secret",
+]