Merge branch 'develop' into feat-makefile-mypy

Author: Michael Brewer

aws_lambda_powertools/event_handler/__init__.py

@@ -2,6 +2,7 @@
 Event handler decorators for common Lambda events
 """
 
+from .api_gateway import ApiGatewayResolver
 from .appsync import AppSyncResolver
 
-__all__ = ["AppSyncResolver"]
+__all__ = ["AppSyncResolver", "ApiGatewayResolver"]

aws_lambda_powertools/event_handler/api_gateway.py

@@ -1,11 +1,18 @@
 import base64
 import json
 import logging
+import os
 import re
+import traceback
 import zlib
 from enum import Enum
+from http import HTTPStatus
 from typing import Any, Callable, Dict, List, Optional, Set, Union
 
+from aws_lambda_powertools.event_handler import content_types
+from aws_lambda_powertools.event_handler.exceptions import ServiceError
+from aws_lambda_powertools.shared import constants
+from aws_lambda_powertools.shared.functions import resolve_truthy_env_var_choice
 from aws_lambda_powertools.shared.json_encoder import Encoder
 from aws_lambda_powertools.utilities.data_classes import ALBEvent, APIGatewayProxyEvent, APIGatewayProxyEventV2
 from aws_lambda_powertools.utilities.data_classes.common import BaseProxyEvent
@@ -25,43 +32,46 @@ class ProxyEventType(Enum):
 class CORSConfig(object):
     """CORS Config
 
-
     Examples
     --------
 
     Simple cors example using the default permissive cors, not this should only be used during early prototyping
 
-        from aws_lambda_powertools.event_handler.api_gateway import ApiGatewayResolver
+    ```python
+    from aws_lambda_powertools.event_handler.api_gateway import ApiGatewayResolver
 
-        app = ApiGatewayResolver()
+    app = ApiGatewayResolver()
 
-        @app.get("/my/path", cors=True)
-        def with_cors():
-            return {"message": "Foo"}
+    @app.get("/my/path", cors=True)
+    def with_cors():
+        return {"message": "Foo"}
+    ```
 
     Using a custom CORSConfig where `with_cors` used the custom provided CORSConfig and `without_cors`
     do not include any cors headers.
 
-        from aws_lambda_powertools.event_handler.api_gateway import (
-            ApiGatewayResolver, CORSConfig
-        )
-
-        cors_config = CORSConfig(
-            allow_origin="https://wwww.example.com/",
-            expose_headers=["x-exposed-response-header"],
-            allow_headers=["x-custom-request-header"],
-            max_age=100,
-            allow_credentials=True,
-        )
-        app = ApiGatewayResolver(cors=cors_config)
-
-        @app.get("/my/path")
-        def with_cors():
-            return {"message": "Foo"}
+    ```python
+    from aws_lambda_powertools.event_handler.api_gateway import (
+        ApiGatewayResolver, CORSConfig
+    )
+
+    cors_config = CORSConfig(
+        allow_origin="https://wwww.example.com/",
+        expose_headers=["x-exposed-response-header"],
+        allow_headers=["x-custom-request-header"],
+        max_age=100,
+        allow_credentials=True,
+    )
+    app = ApiGatewayResolver(cors=cors_config)
+
+    @app.get("/my/path")
+    def with_cors():
+        return {"message": "Foo"}
 
-        @app.get("/another-one", cors=False)
-        def without_cors():
-            return {"message": "Foo"}
+    @app.get("/another-one", cors=False)
+    def without_cors():
+        return {"message": "Foo"}
+    ```
     """
 
     _REQUIRED_HEADERS = ["Authorization", "Content-Type", "X-Amz-Date", "X-Api-Key", "X-Amz-Security-Token"]
@@ -237,20 +247,31 @@ def lambda_handler(event, context):
     current_event: BaseProxyEvent
     lambda_context: LambdaContext
 
-    def __init__(self, proxy_type: Enum = ProxyEventType.APIGatewayProxyEvent, cors: CORSConfig = None):
+    def __init__(
+        self,
+        proxy_type: Enum = ProxyEventType.APIGatewayProxyEvent,
+        cors: CORSConfig = None,
+        debug: Optional[bool] = None,
+    ):
         """
         Parameters
         ----------
         proxy_type: ProxyEventType
             Proxy request type, defaults to API Gateway V1
         cors: CORSConfig
             Optionally configure and enabled CORS. Not each route will need to have to cors=True
+        debug: Optional[bool]
+            Enables debug mode, by default False. Can be also be enabled by "POWERTOOLS_EVENT_HANDLER_DEBUG"
+            environment variable
         """
         self._proxy_type = proxy_type
         self._routes: List[Route] = []
         self._cors = cors
         self._cors_enabled: bool = cors is not None
         self._cors_methods: Set[str] = {"OPTIONS"}
+        self._debug = resolve_truthy_env_var_choice(
+            choice=debug, env=os.getenv(constants.EVENT_HANDLER_DEBUG_ENV, "false")
+        )
 
     def get(self, rule: str, cors: bool = None, compress: bool = False, cache_control: str = None):
         """Get route decorator with GET `method`
@@ -413,6 +434,8 @@ def resolve(self, event, context) -> Dict[str, Any]:
         dict
             Returns the dict response
         """
+        if self._debug:
+            print(self._json_dump(event))
         self.current_event = self._to_proxy_event(event)
         self.lambda_context = context
         return self._resolve().build(self.current_event, self._cors)
@@ -466,19 +489,41 @@ def _not_found(self, method: str) -> ResponseBuilder:
 
         return ResponseBuilder(
             Response(
-                status_code=404,
-                content_type="application/json",
+                status_code=HTTPStatus.NOT_FOUND.value,
+                content_type=content_types.APPLICATION_JSON,
                 headers=headers,
-                body=json.dumps({"message": "Not found"}),
+                body=self._json_dump({"statusCode": HTTPStatus.NOT_FOUND.value, "message": "Not found"}),
             )
         )
 
     def _call_route(self, route: Route, args: Dict[str, str]) -> ResponseBuilder:
         """Actually call the matching route with any provided keyword arguments."""
-        return ResponseBuilder(self._to_response(route.func(**args)), route)
-
-    @staticmethod
-    def _to_response(result: Union[Dict, Response]) -> Response:
+        try:
+            return ResponseBuilder(self._to_response(route.func(**args)), route)
+        except ServiceError as e:
+            return ResponseBuilder(
+                Response(
+                    status_code=e.status_code,
+                    content_type=content_types.APPLICATION_JSON,
+                    body=self._json_dump({"statusCode": e.status_code, "message": e.msg}),
+                ),
+                route,
+            )
+        except Exception:
+            if self._debug:
+                # If the user has turned on debug mode,
+                # we'll let the original exception propagate so
+                # they get more information about what went wrong.
+                return ResponseBuilder(
+                    Response(
+                        status_code=500,
+                        content_type=content_types.TEXT_PLAIN,
+                        body="".join(traceback.format_exc()),
+                    )
+                )
+            raise
+
+    def _to_response(self, result: Union[Dict, Response]) -> Response:
         """Convert the route's result to a Response
 
          2 main result types are supported:
@@ -493,6 +538,13 @@ def _to_response(result: Union[Dict, Response]) -> Response:
         logger.debug("Simple response detected, serializing return before constructing final response")
         return Response(
             status_code=200,
-            content_type="application/json",
-            body=json.dumps(result, separators=(",", ":"), cls=Encoder),
+            content_type=content_types.APPLICATION_JSON,
+            body=self._json_dump(result),
         )
+
+    def _json_dump(self, obj: Any) -> str:
+        """Does a concise json serialization or pretty print when in debug mode"""
+        if self._debug:
+            return json.dumps(obj, indent=4, cls=Encoder)
+        else:
+            return json.dumps(obj, separators=(",", ":"), cls=Encoder)

aws_lambda_powertools/event_handler/content_types.py

@@ -0,0 +1,5 @@
+# use mimetypes library to be certain, e.g., mimetypes.types_map[".json"]
+
+APPLICATION_JSON = "application/json"
+TEXT_PLAIN = "text/plain"
+TEXT_HTML = "text/html"

aws_lambda_powertools/event_handler/exceptions.py

@@ -0,0 +1,45 @@
+from http import HTTPStatus
+
+
+class ServiceError(Exception):
+    """API Gateway and ALB HTTP Service Error"""
+
+    def __init__(self, status_code: int, msg: str):
+        """
+        Parameters
+        ----------
+        status_code: int
+            Http status code
+        msg: str
+            Error message
+        """
+        self.status_code = status_code
+        self.msg = msg
+
+
+class BadRequestError(ServiceError):
+    """API Gateway and ALB Bad Request Error (400)"""
+
+    def __init__(self, msg: str):
+        super().__init__(HTTPStatus.BAD_REQUEST, msg)
+
+
+class UnauthorizedError(ServiceError):
+    """API Gateway and ALB Unauthorized Error (401)"""
+
+    def __init__(self, msg: str):
+        super().__init__(HTTPStatus.UNAUTHORIZED, msg)
+
+
+class NotFoundError(ServiceError):
+    """API Gateway and ALB Not Found Error (404)"""
+
+    def __init__(self, msg: str = "Not found"):
+        super().__init__(HTTPStatus.NOT_FOUND, msg)
+
+
+class InternalServerError(ServiceError):
+    """API Gateway and ALB Not Found Internal Server Error (500)"""
+
+    def __init__(self, message: str):
+        super().__init__(HTTPStatus.INTERNAL_SERVER_ERROR, message)

aws_lambda_powertools/shared/constants.py

@@ -10,11 +10,12 @@
 
 METRICS_NAMESPACE_ENV: str = "POWERTOOLS_METRICS_NAMESPACE"
 
+EVENT_HANDLER_DEBUG_ENV: str = "POWERTOOLS_EVENT_HANDLER_DEBUG"
+
 SAM_LOCAL_ENV: str = "AWS_SAM_LOCAL"
 CHALICE_LOCAL_ENV: str = "AWS_CHALICE_CLI_MODE"
 SERVICE_NAME_ENV: str = "POWERTOOLS_SERVICE_NAME"
 XRAY_TRACE_ID_ENV: str = "_X_AMZN_TRACE_ID"
 
-
-XRAY_SDK_MODULE = "aws_xray_sdk"
-XRAY_SDK_CORE_MODULE = "aws_xray_sdk.core"
+XRAY_SDK_MODULE: str = "aws_xray_sdk"
+XRAY_SDK_CORE_MODULE: str = "aws_xray_sdk.core"

aws_lambda_powertools/utilities/data_classes/appsync/scalar_types_utils.py

@@ -19,15 +19,21 @@ def _formatted_time(now: datetime.date, fmt: str, timezone_offset: int) -> str:
     str
         Returns string formatted time with optional timezone offset
     """
-    if timezone_offset == 0:
-        return now.strftime(fmt + "Z")
+    if timezone_offset != 0:
+        now = now + datetime.timedelta(hours=timezone_offset)
+
+    datetime_str = now.strftime(fmt)
+    if fmt.endswith(".%f"):
+        datetime_str = datetime_str[:-3]
 
-    now = now + datetime.timedelta(hours=timezone_offset)
-    fmt += "+" if timezone_offset > 0 else "-"
-    fmt += str(abs(timezone_offset)).zfill(2)
-    fmt += ":00:00"
+    if timezone_offset == 0:
+        postfix = "Z"
+    else:
+        postfix = "+" if timezone_offset > 0 else "-"
+        postfix += str(abs(timezone_offset)).zfill(2)
+        postfix += ":00:00"
 
-    return now.strftime(fmt)
+    return datetime_str + postfix
 
 
 def make_id() -> str:
@@ -65,7 +71,7 @@ def aws_time(timezone_offset: int = 0) -> str:
     str
         Returns current time as AWSTime scalar string with optional timezone offset
     """
-    return _formatted_time(datetime.datetime.utcnow(), "%H:%M:%S", timezone_offset)
+    return _formatted_time(datetime.datetime.utcnow(), "%H:%M:%S.%f", timezone_offset)
 
 
 def aws_datetime(timezone_offset: int = 0) -> str:
@@ -81,7 +87,7 @@ def aws_datetime(timezone_offset: int = 0) -> str:
     str
         Returns current time as AWSDateTime scalar string with optional timezone offset
     """
-    return _formatted_time(datetime.datetime.utcnow(), "%Y-%m-%dT%H:%M:%S", timezone_offset)
+    return _formatted_time(datetime.datetime.utcnow(), "%Y-%m-%dT%H:%M:%S.%f", timezone_offset)
 
 
 def aws_timestamp() -> int: