Merge branch 'master' into toxgen/update

Author: sentrivana

sentry_sdk/integrations/aws_lambda.py

@@ -138,6 +138,8 @@ def sentry_handler(aws_event, aws_context, *args, **kwargs):
                     timeout_thread = TimeoutThread(
                         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

sentry_sdk/integrations/gcp.py

@@ -75,7 +75,12 @@ def sentry_func(functionhandler, gcp_event, *args, **kwargs):
                 ):
                     waiting_time = configured_time - TIMEOUT_WARNING_BUFFER
 
-                    timeout_thread = TimeoutThread(waiting_time, configured_time)
+                    timeout_thread = TimeoutThread(
+                        waiting_time,
+                        configured_time,
+                        isolation_scope=scope,
+                        current_scope=sentry_sdk.get_current_scope(),
+                    )
 
                     # Starting the thread to raise timeout warning exception
                     timeout_thread.start()

sentry_sdk/utils.py

@@ -1484,17 +1484,37 @@ class TimeoutThread(threading.Thread):
     waiting_time and raises a custom ServerlessTimeout exception.
     """
 
-    def __init__(self, waiting_time, configured_timeout):
-        # type: (float, int) -> None
+    def __init__(
+        self, waiting_time, configured_timeout, isolation_scope=None, current_scope=None
+    ):
+        # type: (float, int, Optional[sentry_sdk.Scope], Optional[sentry_sdk.Scope]) -> None
         threading.Thread.__init__(self)
         self.waiting_time = waiting_time
         self.configured_timeout = configured_timeout
+
+        self.isolation_scope = isolation_scope
+        self.current_scope = current_scope
+
         self._stop_event = threading.Event()
 
     def stop(self):
         # type: () -> None
         self._stop_event.set()
 
+    def _capture_exception(self):
+        # type: () -> ExcInfo
+        exc_info = sys.exc_info()
+
+        client = sentry_sdk.get_client()
+        event, hint = event_from_exception(
+            exc_info,
+            client_options=client.options,
+            mechanism={"type": "threading", "handled": False},
+        )
+        sentry_sdk.capture_event(event, hint=hint)
+
+        return exc_info
+
     def run(self):
         # type: () -> None
 
@@ -1510,6 +1530,18 @@ def run(self):
             integer_configured_timeout = integer_configured_timeout + 1
 
         # Raising Exception after timeout duration is reached
+        if self.isolation_scope is not None and self.current_scope is not None:
+            with sentry_sdk.scope.use_isolation_scope(self.isolation_scope):
+                with sentry_sdk.scope.use_scope(self.current_scope):
+                    try:
+                        raise ServerlessTimeoutWarning(
+                            "WARNING : Function is expected to get timed out. Configured timeout duration = {} seconds.".format(
+                                integer_configured_timeout
+                            )
+                        )
+                    except Exception:
+                        reraise(*self._capture_exception())
+
         raise ServerlessTimeoutWarning(
             "WARNING : Function is expected to get timed out. Configured timeout duration = {} seconds.".format(
                 integer_configured_timeout

tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/TimeoutErrorScopeModified/.gitignore

@@ -0,0 +1,11 @@
+# Need to add some ignore rules in this directory, because the unit tests will add the Sentry SDK and its dependencies
+# into this directory to create a Lambda function package that contains everything needed to instrument a Lambda function using Sentry.
+
+# Ignore everything
+*
+
+# But not index.py
+!index.py
+
+# And not .gitignore itself
+!.gitignore

tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/TimeoutErrorScopeModified/index.py

@@ -0,0 +1,19 @@
+import os
+import time
+
+import sentry_sdk
+from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
+
+sentry_sdk.init(
+    dsn=os.environ.get("SENTRY_DSN"),
+    traces_sample_rate=1.0,
+    integrations=[AwsLambdaIntegration(timeout_warning=True)],
+)
+
+
+def handler(event, context):
+    sentry_sdk.set_tag("custom_tag", "custom_value")
+    time.sleep(15)
+    return {
+        "event": event,
+    }

tests/integrations/aws_lambda/test_aws_lambda.py

@@ -223,6 +223,31 @@ def test_timeout_error(lambda_client, test_environment):
     assert exception["mechanism"]["type"] == "threading"
 
 
+def test_timeout_error_scope_modified(lambda_client, test_environment):
+    lambda_client.invoke(
+        FunctionName="TimeoutErrorScopeModified",
+        Payload=json.dumps({}),
+    )
+    envelopes = test_environment["server"].envelopes
+
+    (error_event,) = envelopes
+
+    assert error_event["level"] == "error"
+    assert (
+        error_event["extra"]["lambda"]["function_name"] == "TimeoutErrorScopeModified"
+    )
+
+    (exception,) = error_event["exception"]["values"]
+    assert not exception["mechanism"]["handled"]
+    assert exception["type"] == "ServerlessTimeoutWarning"
+    assert exception["value"].startswith(
+        "WARNING : Function is expected to get timed out. Configured timeout duration ="
+    )
+    assert exception["mechanism"]["type"] == "threading"
+
+    assert error_event["tags"]["custom_tag"] == "custom_value"
+
+
 @pytest.mark.parametrize(
     "aws_event, has_request_data, batch_size",
     [

tests/integrations/gcp/test_gcp.py

@@ -196,6 +196,7 @@ def test_timeout_error(run_cloud_function):
         functionhandler = None
         event = {}
         def cloud_function(functionhandler, event):
+            sentry_sdk.set_tag("cloud_function", "true")
             time.sleep(10)
             return "3"
         """
@@ -219,6 +220,8 @@ def cloud_function(functionhandler, event):
     assert exception["mechanism"]["type"] == "threading"
     assert not exception["mechanism"]["handled"]
 
+    assert envelope_items[0]["tags"]["cloud_function"] == "true"
+
 
 def test_performance_no_error(run_cloud_function):
     envelope_items, _ = run_cloud_function(