Use Timer to finish transaction

Author: antonpirker

sentry_sdk/integrations/wsgi.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone
 import sys
 from functools import partial
+from threading import Timer
 
 import sentry_sdk
 from sentry_sdk._werkzeug import get_host, _get_headers
@@ -46,7 +47,7 @@ def __call__(self, status, response_headers, exc_info=None):  # type: ignore
             pass
 
 
-MAX_TRANSACTION_DURATION_MINUTES = 5
+MAX_TRANSACTION_DURATION_SECONDS = 5 * 60
 
 
 _wsgi_middleware_applied = ContextVar("sentry_wsgi_middleware_applied")
@@ -128,7 +129,12 @@ def __call__(self, environ, start_response):
                             transaction,
                             custom_sampling_context={"wsgi_environ": environ},
                         ).__enter__()
-
+                        timer = Timer(
+                            MAX_TRANSACTION_DURATION_SECONDS,
+                            finish_long_running_transaction,
+                            args=(current_scope, scope),
+                        )
+                        timer.start()
                     try:
                         response = self.app(
                             environ,
@@ -235,6 +241,25 @@ def _capture_exception(exc_info=None):
     return exc_info
 
 
+def finish_long_running_transaction(current_scope, isolation_scope):
+    # type: (sentry_sdk.scope.Scope, sentry_sdk.scope.Scope) -> None
+    """
+    Make sure we don't keep transactions open for too long.
+    Triggered after MAX_TRANSACTION_DURATION_SECONDS have passed.
+    """
+    try:
+        transaction_duration = (
+            datetime.now(timezone.utc) - current_scope.transaction.start_timestamp
+        ).total_seconds()
+        if transaction_duration > MAX_TRANSACTION_DURATION_SECONDS:
+            with use_isolation_scope(isolation_scope):
+                with use_scope(current_scope):
+                    finish_running_transaction()
+    except AttributeError:
+        # transaction is not there anymore
+        pass
+
+
 class _ScopedResponse:
     """
     Use separate scopes for each response chunk.
@@ -276,17 +301,6 @@ def __iter__(self):
 
                 yield chunk
 
-                # Finish long running transactions at some point
-                try:
-                    transaction_duration = (datetime.now(timezone.utc) - self._current_scope.transaction.start_timestamp).total_seconds() / 60
-                    if transaction_duration > MAX_TRANSACTION_DURATION_MINUTES:
-                        with use_isolation_scope(self._isolation_scope):
-                            with use_scope(self._current_scope):
-                                finish_running_transaction(self._current_scope)
-                except AttributeError:
-                    # transaction is not there anymore
-                    pass
-
         finally:
             with use_isolation_scope(self._isolation_scope):
                 with use_scope(self._current_scope):

tests/integrations/wsgi/test_wsgi.py

@@ -501,9 +501,9 @@ def dogpark(environ, start_response):
 
 def test_long_running_transaction_finished(sentry_init, capture_events):
     # we allow transactions to be 0.5 seconds as a maximum
-    new_max_duration = 0.5 / 60
+    new_max_duration = 0.5
 
-    with mock.patch.object(sentry_sdk.integrations.wsgi, "MAX_TRANSACTION_DURATION_MINUTES", new_max_duration):
+    with mock.patch.object(sentry_sdk.integrations.wsgi, "MAX_TRANSACTION_DURATION_SECONDS", new_max_duration):
         def generate_content():
             # This response will take 1.5 seconds to generate
             for _ in range(15):
@@ -525,5 +525,5 @@ def long_running_app(environ, start_response):
 
         (transaction,) = events
 
-        transaction_duration = (datetime_from_isoformat(transaction["timestamp"]) - datetime_from_isoformat(transaction["start_timestamp"])).total_seconds() / 60
-        assert transaction_duration <= new_max_duration * 1.05  # we allow 2% error margin for processing the request
+        transaction_duration = (datetime_from_isoformat(transaction["timestamp"]) - datetime_from_isoformat(transaction["start_timestamp"])).total_seconds()
+        assert transaction_duration <= new_max_duration * 1.2  # we allow 2% margin for processing the request