sentry-sdk 0.18.0__py2.py3-none-any.whl → 2.46.0__py2.py3-none-any.whl

sentry_sdk/integrations/aws_lambda.py

@@ -1,23 +1,31 @@
-from datetime import datetime, timedelta
-from os import environ
+import functools
+import json
+import re
 import sys
+from copy import deepcopy
+from datetime import datetime, timedelta, timezone
+from os import environ
 
-from sentry_sdk.hub import Hub, _should_send_default_pii
-from sentry_sdk.tracing import Transaction
-from sentry_sdk._compat import reraise
+import sentry_sdk
+from sentry_sdk.api import continue_trace
+from sentry_sdk.consts import OP
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.tracing import TransactionSource
 from sentry_sdk.utils import (
     AnnotatedValue,
     capture_internal_exceptions,
+    ensure_integration_enabled,
     event_from_exception,
     logger,
     TimeoutThread,
+    reraise,
 )
 from sentry_sdk.integrations import Integration
 from sentry_sdk.integrations._wsgi_common import _filter_headers
 
-from sentry_sdk._types import MYPY
+from typing import TYPE_CHECKING
 
-if MYPY:
+if TYPE_CHECKING:
     from typing import Any
     from typing import TypeVar
     from typing import Callable
@@ -34,29 +42,30 @@ MILLIS_TO_SECONDS = 1000.0
 
 def _wrap_init_error(init_error):
     # type: (F) -> F
+    @ensure_integration_enabled(AwsLambdaIntegration, init_error)
     def sentry_init_error(*args, **kwargs):
         # type: (*Any, **Any) -> Any
-
-        hub = Hub.current
-        integration = hub.get_integration(AwsLambdaIntegration)
-        if integration is None:
-            return init_error(*args, **kwargs)
-
-        # If an integration is there, a client has to be there.
-        client = hub.client  # type: Any
+        client = sentry_sdk.get_client()
 
         with capture_internal_exceptions():
-            with hub.configure_scope() as scope:
-                scope.clear_breadcrumbs()
+            sentry_sdk.get_isolation_scope().clear_breadcrumbs()
 
             exc_info = sys.exc_info()
             if exc_info and all(exc_info):
-                event, hint = event_from_exception(
+                sentry_event, hint = event_from_exception(
                     exc_info,
                     client_options=client.options,
                     mechanism={"type": "aws_lambda", "handled": False},
                 )
-                hub.capture_event(event, hint=hint)
+                sentry_sdk.capture_event(sentry_event, hint=hint)
+
+            else:
+                # Fall back to AWS lambdas JSON representation of the error
+                error_info = args[1]
+                if isinstance(error_info, str):
+                    error_info = json.loads(error_info)
+                sentry_event = _event_from_error_json(error_info)
+                sentry_sdk.capture_event(sentry_event)
 
         return init_error(*args, **kwargs)
 
@@ -65,24 +74,57 @@ def _wrap_init_error(init_error):
 
 def _wrap_handler(handler):
     # type: (F) -> F
-    def sentry_handler(event, context, *args, **kwargs):
+    @functools.wraps(handler)
+    def sentry_handler(aws_event, aws_context, *args, **kwargs):
         # type: (Any, Any, *Any, **Any) -> Any
-        hub = Hub.current
-        integration = hub.get_integration(AwsLambdaIntegration)
+
+        # Per https://docs.aws.amazon.com/lambda/latest/dg/python-handler.html,
+        # `event` here is *likely* a dictionary, but also might be a number of
+        # other types (str, int, float, None).
+        #
+        # In some cases, it is a list (if the user is batch-invoking their
+        # function, for example), in which case we'll use the first entry as a
+        # representative from which to try pulling request data. (Presumably it
+        # will be the same for all events in the list, since they're all hitting
+        # the lambda in the same request.)
+
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(AwsLambdaIntegration)
+
         if integration is None:
-            return handler(event, context, *args, **kwargs)
+            return handler(aws_event, aws_context, *args, **kwargs)
+
+        if isinstance(aws_event, list) and len(aws_event) >= 1:
+            request_data = aws_event[0]
+            batch_size = len(aws_event)
+        else:
+            request_data = aws_event
+            batch_size = 1
+
+        if not isinstance(request_data, dict):
+            # If we're not dealing with a dictionary, we won't be able to get
+            # headers, path, http method, etc in any case, so it's fine that
+            # this is empty
+            request_data = {}
 
-        # If an integration is there, a client has to be there.
-        client = hub.client  # type: Any
-        configured_time = context.get_remaining_time_in_millis()
+        configured_time = aws_context.get_remaining_time_in_millis()
 
-        with hub.push_scope() as scope:
+        with sentry_sdk.isolation_scope() as scope:
+            timeout_thread = None
             with capture_internal_exceptions():
                 scope.clear_breadcrumbs()
                 scope.add_event_processor(
-                    _make_request_event_processor(event, context, configured_time)
+                    _make_request_event_processor(
+                        request_data, aws_context, configured_time
+                    )
+                )
+                scope.set_tag(
+                    "aws_region", aws_context.invoked_function_arn.split(":")[3]
                 )
-                scope.set_tag("aws_region", context.invoked_function_arn.split(":")[3])
+                if batch_size > 1:
+                    scope.set_tag("batch_request", True)
+                    scope.set_tag("batch_size", batch_size)
+
                 # Starting the Timeout thread only if the configured time is greater than Timeout warning
                 # buffer and timeout_warning parameter is set True.
                 if (
@@ -94,28 +136,49 @@ def _wrap_handler(handler):
                     ) / MILLIS_TO_SECONDS
 
                     timeout_thread = TimeoutThread(
-                        waiting_time, configured_time / MILLIS_TO_SECONDS
+                        waiting_time,
+                        configured_time / MILLIS_TO_SECONDS,
+                        isolation_scope=scope,
+                        current_scope=sentry_sdk.get_current_scope(),
                     )
 
                     # Starting the thread to raise timeout warning exception
                     timeout_thread.start()
 
-            headers = event.get("headers", {})
-            transaction = Transaction.continue_from_headers(
-                headers, op="serverless.function", name=context.function_name
+            headers = request_data.get("headers", {})
+            # Some AWS Services (ie. EventBridge) set headers as a list
+            # or None, so we must ensure it is a dict
+            if not isinstance(headers, dict):
+                headers = {}
+
+            transaction = continue_trace(
+                headers,
+                op=OP.FUNCTION_AWS,
+                name=aws_context.function_name,
+                source=TransactionSource.COMPONENT,
+                origin=AwsLambdaIntegration.origin,
             )
-            with hub.start_transaction(transaction):
+            with sentry_sdk.start_transaction(
+                transaction,
+                custom_sampling_context={
+                    "aws_event": aws_event,
+                    "aws_context": aws_context,
+                },
+            ):
                 try:
-                    return handler(event, context, *args, **kwargs)
+                    return handler(aws_event, aws_context, *args, **kwargs)
                 except Exception:
                     exc_info = sys.exc_info()
-                    event, hint = event_from_exception(
+                    sentry_event, hint = event_from_exception(
                         exc_info,
                         client_options=client.options,
                         mechanism={"type": "aws_lambda", "handled": False},
                     )
-                    hub.capture_event(event, hint=hint)
+                    sentry_sdk.capture_event(sentry_event, hint=hint)
                     reraise(*exc_info)
+                finally:
+                    if timeout_thread:
+                        timeout_thread.stop()
 
     return sentry_handler  # type: ignore
 
@@ -123,16 +186,17 @@ def _wrap_handler(handler):
 def _drain_queue():
     # type: () -> None
     with capture_internal_exceptions():
-        hub = Hub.current
-        integration = hub.get_integration(AwsLambdaIntegration)
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(AwsLambdaIntegration)
         if integration is not None:
             # Flush out the event queue before AWS kills the
             # process.
-            hub.flush()
+            client.flush()
 
 
 class AwsLambdaIntegration(Integration):
     identifier = "aws_lambda"
+    origin = f"auto.function.{identifier}"
 
     def __init__(self, timeout_warning=False):
         # type: (bool) -> None
@@ -142,23 +206,8 @@ class AwsLambdaIntegration(Integration):
     def setup_once():
         # type: () -> None
 
-        # Python 2.7: Everything is in `__main__`.
-        #
-        # Python 3.7: If the bootstrap module is *already imported*, it is the
-        # one we actually want to use (no idea what's in __main__)
-        #
-        # On Python 3.8 bootstrap is also importable, but will be the same file
-        # as __main__ imported under a different name:
-        #
-        #     sys.modules['__main__'].__file__ == sys.modules['bootstrap'].__file__
-        #     sys.modules['__main__'] is not sys.modules['bootstrap']
-        #
-        # Such a setup would then make all monkeypatches useless.
-        if "bootstrap" in sys.modules:
-            lambda_bootstrap = sys.modules["bootstrap"]  # type: Any
-        elif "__main__" in sys.modules:
-            lambda_bootstrap = sys.modules["__main__"]
-        else:
+        lambda_bootstrap = get_lambda_bootstrap()
+        if not lambda_bootstrap:
             logger.warning(
                 "Not running in AWS Lambda environment, "
                 "AwsLambdaIntegration disabled (could not find bootstrap module)"
@@ -172,7 +221,7 @@ class AwsLambdaIntegration(Integration):
             )
             return
 
-        pre_37 = hasattr(lambda_bootstrap, "handle_http_request")  # Python 3.6 or 2.7
+        pre_37 = hasattr(lambda_bootstrap, "handle_http_request")  # Python 3.6
 
         if pre_37:
             old_handle_event_request = lambda_bootstrap.handle_event_request
@@ -245,16 +294,53 @@ class AwsLambdaIntegration(Integration):
             )
 
 
+def get_lambda_bootstrap():
+    # type: () -> Optional[Any]
+
+    # Python 3.7: If the bootstrap module is *already imported*, it is the
+    # one we actually want to use (no idea what's in __main__)
+    #
+    # Python 3.8: bootstrap is also importable, but will be the same file
+    # as __main__ imported under a different name:
+    #
+    #     sys.modules['__main__'].__file__ == sys.modules['bootstrap'].__file__
+    #     sys.modules['__main__'] is not sys.modules['bootstrap']
+    #
+    # Python 3.9: bootstrap is in __main__.awslambdaricmain
+    #
+    # On container builds using the `aws-lambda-python-runtime-interface-client`
+    # (awslamdaric) module, bootstrap is located in sys.modules['__main__'].bootstrap
+    #
+    # Such a setup would then make all monkeypatches useless.
+    if "bootstrap" in sys.modules:
+        return sys.modules["bootstrap"]
+    elif "__main__" in sys.modules:
+        module = sys.modules["__main__"]
+        # python3.9 runtime
+        if hasattr(module, "awslambdaricmain") and hasattr(
+            module.awslambdaricmain, "bootstrap"
+        ):
+            return module.awslambdaricmain.bootstrap
+        elif hasattr(module, "bootstrap"):
+            # awslambdaric python module in container builds
+            return module.bootstrap
+
+        # python3.8 runtime
+        return module
+    else:
+        return None
+
+
 def _make_request_event_processor(aws_event, aws_context, configured_timeout):
     # type: (Any, Any, Any) -> EventProcessor
-    start_time = datetime.utcnow()
+    start_time = datetime.now(timezone.utc)
 
-    def event_processor(event, hint, start_time=start_time):
+    def event_processor(sentry_event, hint, start_time=start_time):
         # type: (Event, Hint, datetime) -> Optional[Event]
         remaining_time_in_milis = aws_context.get_remaining_time_in_millis()
         exec_duration = configured_timeout - remaining_time_in_milis
 
-        extra = event.setdefault("extra", {})
+        extra = sentry_event.setdefault("extra", {})
         extra["lambda"] = {
             "function_name": aws_context.function_name,
             "function_version": aws_context.function_version,
@@ -270,7 +356,7 @@ def _make_request_event_processor(aws_event, aws_context, configured_timeout):
             "log_stream": aws_context.log_stream_name,
         }
 
-        request = event.get("request", {})
+        request = sentry_event.get("request", {})
 
         if "httpMethod" in aws_event:
             request["method"] = aws_event["httpMethod"]
@@ -283,14 +369,18 @@ def _make_request_event_processor(aws_event, aws_context, configured_timeout):
         if "headers" in aws_event:
             request["headers"] = _filter_headers(aws_event["headers"])
 
-        if _should_send_default_pii():
-            user_info = event.setdefault("user", {})
+        if should_send_default_pii():
+            user_info = sentry_event.setdefault("user", {})
 
-            id = aws_event.get("identity", {}).get("userArn")
+            identity = aws_event.get("identity")
+            if identity is None:
+                identity = {}
+
+            id = identity.get("userArn")
             if id is not None:
                 user_info.setdefault("id", id)
 
-            ip = aws_event.get("identity", {}).get("sourceIp")
+            ip = identity.get("sourceIp")
             if ip is not None:
                 user_info.setdefault("ip_address", ip)
 
@@ -300,49 +390,112 @@ def _make_request_event_processor(aws_event, aws_context, configured_timeout):
             if aws_event.get("body", None):
                 # Unfortunately couldn't find a way to get structured body from AWS
                 # event. Meaning every body is unstructured to us.
-                request["data"] = AnnotatedValue("", {"rem": [["!raw", "x", 0, 0]]})
+                request["data"] = AnnotatedValue.removed_because_raw_data()
 
-        event["request"] = request
+        sentry_event["request"] = deepcopy(request)
 
-        return event
+        return sentry_event
 
     return event_processor
 
 
-def _get_url(event, context):
+def _get_url(aws_event, aws_context):
     # type: (Any, Any) -> str
-    path = event.get("path", None)
-    headers = event.get("headers", {})
+    path = aws_event.get("path", None)
+
+    headers = aws_event.get("headers")
+    if headers is None:
+        headers = {}
+
     host = headers.get("Host", None)
     proto = headers.get("X-Forwarded-Proto", None)
     if proto and host and path:
         return "{}://{}{}".format(proto, host, path)
-    return "awslambda:///{}".format(context.function_name)
+    return "awslambda:///{}".format(aws_context.function_name)
 
 
-def _get_cloudwatch_logs_url(context, start_time):
+def _get_cloudwatch_logs_url(aws_context, start_time):
     # type: (Any, datetime) -> str
     """
     Generates a CloudWatchLogs console URL based on the context object
 
     Arguments:
-        context {Any} -- context from lambda handler
+        aws_context {Any} -- context from lambda handler
 
     Returns:
         str -- AWS Console URL to logs.
     """
     formatstring = "%Y-%m-%dT%H:%M:%SZ"
+    region = environ.get("AWS_REGION", "")
 
     url = (
-        "https://console.aws.amazon.com/cloudwatch/home?region={region}"
+        "https://console.{domain}/cloudwatch/home?region={region}"
         "#logEventViewer:group={log_group};stream={log_stream}"
         ";start={start_time};end={end_time}"
     ).format(
-        region=environ.get("AWS_REGION"),
-        log_group=context.log_group_name,
-        log_stream=context.log_stream_name,
+        domain="amazonaws.cn" if region.startswith("cn-") else "aws.amazon.com",
+        region=region,
+        log_group=aws_context.log_group_name,
+        log_stream=aws_context.log_stream_name,
         start_time=(start_time - timedelta(seconds=1)).strftime(formatstring),
-        end_time=(datetime.utcnow() + timedelta(seconds=2)).strftime(formatstring),
+        end_time=(datetime.now(timezone.utc) + timedelta(seconds=2)).strftime(
+            formatstring
+        ),
     )
 
     return url
+
+
+def _parse_formatted_traceback(formatted_tb):
+    # type: (list[str]) -> list[dict[str, Any]]
+    frames = []
+    for frame in formatted_tb:
+        match = re.match(r'File "(.+)", line (\d+), in (.+)', frame.strip())
+        if match:
+            file_name, line_number, func_name = match.groups()
+            line_number = int(line_number)
+            frames.append(
+                {
+                    "filename": file_name,
+                    "function": func_name,
+                    "lineno": line_number,
+                    "vars": None,
+                    "pre_context": None,
+                    "context_line": None,
+                    "post_context": None,
+                }
+            )
+    return frames
+
+
+def _event_from_error_json(error_json):
+    # type: (dict[str, Any]) -> Event
+    """
+    Converts the error JSON from AWS Lambda into a Sentry error event.
+    This is not a full fletched event, but better than nothing.
+
+    This is an example of where AWS creates the error JSON:
+    https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/2.2.1/awslambdaric/bootstrap.py#L479
+    """
+    event = {
+        "level": "error",
+        "exception": {
+            "values": [
+                {
+                    "type": error_json.get("errorType"),
+                    "value": error_json.get("errorMessage"),
+                    "stacktrace": {
+                        "frames": _parse_formatted_traceback(
+                            error_json.get("stackTrace", [])
+                        ),
+                    },
+                    "mechanism": {
+                        "type": "aws_lambda",
+                        "handled": False,
+                    },
+                }
+            ],
+        },
+    }  # type: Event
+
+    return event

sentry_sdk/integrations/beam.py

@@ -1,24 +1,25 @@
-from __future__ import absolute_import
-
 import sys
 import types
-from sentry_sdk._functools import wraps
+from functools import wraps
 
-from sentry_sdk.hub import Hub
-from sentry_sdk._compat import reraise
-from sentry_sdk.utils import capture_internal_exceptions, event_from_exception
+import sentry_sdk
 from sentry_sdk.integrations import Integration
 from sentry_sdk.integrations.logging import ignore_logger
-from sentry_sdk._types import MYPY
+from sentry_sdk.utils import (
+    capture_internal_exceptions,
+    ensure_integration_enabled,
+    event_from_exception,
+    reraise,
+)
+
+from typing import TYPE_CHECKING
 
-if MYPY:
+if TYPE_CHECKING:
     from typing import Any
     from typing import Iterator
     from typing import TypeVar
-    from typing import Optional
     from typing import Callable
 
-    from sentry_sdk.client import Client
     from sentry_sdk._types import ExcInfo
 
     T = TypeVar("T")
@@ -80,7 +81,6 @@ class BeamIntegration(Integration):
 
 def _wrap_inspect_call(cls, func_name):
     # type: (Any, Any) -> Any
-    from apache_beam.typehints.decorators import getfullargspec  # type: ignore
 
     if not hasattr(cls, func_name):
         return None
@@ -105,6 +105,8 @@ def _wrap_inspect_call(cls, func_name):
 
             return get_function_args_defaults(process_func)
         except ImportError:
+            from apache_beam.typehints.decorators import getfullargspec  # type: ignore
+
             return getfullargspec(process_func)
 
     setattr(_inspect, USED_FUNC, True)
@@ -115,9 +117,7 @@ def _wrap_task_call(func):
     # type: (F) -> F
     """
     Wrap task call with a try catch to get exceptions.
-    Pass the client on to raise_exception so it can get rebinded.
     """
-    client = Hub.current.client
 
     @wraps(func)
     def _inner(*args, **kwargs):
@@ -125,53 +125,45 @@ def _wrap_task_call(func):
         try:
             gen = func(*args, **kwargs)
         except Exception:
-            raise_exception(client)
+            raise_exception()
 
         if not isinstance(gen, types.GeneratorType):
             return gen
-        return _wrap_generator_call(gen, client)
+        return _wrap_generator_call(gen)
 
     setattr(_inner, USED_FUNC, True)
     return _inner  # type: ignore
 
 
-def _capture_exception(exc_info, hub):
-    # type: (ExcInfo, Hub) -> None
+@ensure_integration_enabled(BeamIntegration)
+def _capture_exception(exc_info):
+    # type: (ExcInfo) -> None
     """
     Send Beam exception to Sentry.
     """
-    integration = hub.get_integration(BeamIntegration)
-    if integration is None:
-        return
-
-    client = hub.client
-    if client is None:
-        return
+    client = sentry_sdk.get_client()
 
     event, hint = event_from_exception(
         exc_info,
         client_options=client.options,
         mechanism={"type": "beam", "handled": False},
     )
-    hub.capture_event(event, hint=hint)
+    sentry_sdk.capture_event(event, hint=hint)
 
 
-def raise_exception(client):
-    # type: (Optional[Client]) -> None
+def raise_exception():
+    # type: () -> None
     """
-    Raise an exception. If the client is not in the hub, rebind it.
+    Raise an exception.
     """
-    hub = Hub.current
-    if hub.client is None:
-        hub.bind_client(client)
     exc_info = sys.exc_info()
     with capture_internal_exceptions():
-        _capture_exception(exc_info, hub)
+        _capture_exception(exc_info)
     reraise(*exc_info)
 
 
-def _wrap_generator_call(gen, client):
-    # type: (Iterator[T], Optional[Client]) -> Iterator[T]
+def _wrap_generator_call(gen):
+    # type: (Iterator[T]) -> Iterator[T]
     """
     Wrap the generator to handle any failures.
     """
@@ -181,4 +173,4 @@ def _wrap_generator_call(gen, client):
         except StopIteration:
             break
         except Exception:
-            raise_exception(client)
+            raise_exception()