Version without timer thread

Author: antonpirker

sentry_sdk/integrations/wsgi.py

@@ -1,7 +1,5 @@
 import sys
-from contextlib import nullcontext
 from functools import partial
-from threading import Timer
 
 import sentry_sdk
 from sentry_sdk._werkzeug import get_host, _get_headers
@@ -132,7 +130,6 @@ def __call__(self, environ, start_response):
                     transaction = None
 
                     with sentry_sdk.continue_trace(environ):
-                        timer = None
                         if should_trace:
                             transaction = sentry_sdk.start_span(
                                 op=OP.HTTP_SERVER,
@@ -146,18 +143,6 @@ def __call__(self, environ, start_response):
                             transaction.__enter__()
                             current_scope = transaction.scope
 
-                            timer = Timer(
-                                MAX_TRANSACTION_DURATION_SECONDS,
-                                finish_running_transaction,
-                                kwargs={
-                                    "transaction": transaction,
-                                    "current_scope": current_scope,
-                                    "isolation_scope": scope,
-                                    "debug": "from timer!",
-                                },
-                            )
-                            timer.start()
-
                             try:
                                 response = self.app(
                                     environ,
@@ -170,7 +155,7 @@ def __call__(self, environ, start_response):
                             except BaseException:
                                 exc_info = sys.exc_info()
                                 _capture_exception(exc_info)
-                                finish_running_transaction(transaction, exc_info, timer, debug="from except block")
+                                finish_running_transaction(transaction, exc_info)
                                 reraise(*exc_info)
 
         finally:
@@ -180,7 +165,6 @@ def __call__(self, environ, start_response):
             response=response,
             current_scope=current_scope,
             isolation_scope=scope,
-            timer=timer,
             transaction=transaction,
         )
 
@@ -277,21 +261,19 @@ class _ScopedResponse:
     - WSGI servers streaming responses interleaved from the same thread
     """
 
-    __slots__ = ("_response", "_current_scope", "_isolation_scope", "_timer", "_transaction")
+    __slots__ = ("_response", "_current_scope", "_isolation_scope", "_transaction")
 
     def __init__(
         self,
         response,  # type: Iterator[bytes]
         current_scope,  # type: sentry_sdk.scope.Scope
         isolation_scope,  # type: sentry_sdk.scope.Scope
-        timer=None,  # type: Optional[Timer]
         transaction=None,  # type: Optional[Transaction]
     ):
         # type: (...) -> None
         self._response = response
         self._current_scope = current_scope
         self._isolation_scope = isolation_scope
-        self._timer = timer
         self._transaction = transaction
 
     def __iter__(self):
@@ -314,14 +296,14 @@ def __iter__(self):
         finally:
             with sentry_sdk.use_isolation_scope(self._isolation_scope):
                 with sentry_sdk.use_scope(self._current_scope):
-                    finish_running_transaction(transaction=self._transaction, timer=self._timer, debug="from finally in iterator")
+                    finish_running_transaction(transaction=self._transaction)
 
     def close(self):
         # type: () -> None
         with sentry_sdk.use_isolation_scope(self._isolation_scope):
             with sentry_sdk.use_scope(self._current_scope):
                 try:
-                    finish_running_transaction(transaction=self._transaction, timer=self._timer, debug="from close()")
+                    finish_running_transaction(transaction=self._transaction)
                     self._response.close()  # type: ignore
                 except AttributeError:
                     pass

sentry_sdk/tracing_utils.py

@@ -739,39 +739,10 @@ def get_current_span(scope=None):
     from sentry_sdk.tracing import Span
 
 
-def finish_running_transaction(transaction=None, exc_info=None, timer=None, current_scope=None, isolation_scope=None, debug=None):
-    # type: (Optional[sentry_sdk.Transaction], Optional[ExcInfo], Optional[Timer]) -> None
-    print(f"----")
-    print(f"\nCALLED finish_running_transaction {id(transaction)} / {transaction} / {exc_info} / {timer} / {current_scope} / {isolation_scope} / debug: {debug}")
-    import traceback
-    traceback.print_stack()
-    # print(f"{id(transaction)} / {sentry_sdk.get_current_scope().transaction}")
-    print(f"hasattr _ctx_token: {hasattr(transaction, '_ctx_token')}")
-    # print(f"_ctx_token: {transaction._ctx_token}")
-
-    if timer is not None:
-        timer.cancel()
-
+def finish_running_transaction(transaction=None, exc_info=None):
+    # type: (Optional[sentry_sdk.Transaction], Optional[ExcInfo]) -> None
     if transaction is not None and hasattr(transaction, "_ctx_token"):
-        with (
-            sentry_sdk.use_isolation_scope(isolation_scope)
-            if isolation_scope is not None
-            else contextlib.nullcontext()
-        ) as scope1:
-            with (
-                sentry_sdk.use_scope(current_scope)
-                if current_scope is not None
-                else contextlib.nullcontext()
-            ) as scope2:
-                if exc_info is not None:
-                    transaction.__exit__(*exc_info)
-                else:
-                    transaction.__exit__(None, None, None)
-
-                print(f"End of current scope: {scope2}")
-
-            print(f"End of isolation scope: {scope1}")
-    else:
-        print(f"Transaction has no _ctx_token")
-
-    print("done finish_running_transaction")
+        if exc_info is not None:
+            transaction.__exit__(*exc_info)
+        else:
+            transaction.__exit__(None, None, None)

tests/integrations/wsgi/test_wsgi.py

@@ -497,7 +497,7 @@ def dogpark(environ, start_response):
 
 def test_long_running_transaction_finished(sentry_init, capture_events):
     """
-    Test that a long running transaction is finished after the maximum duration, 
+    Test that a long running transaction is finished after the maximum duration,
     no matter if the response is still being generated.
     """
     # we allow transactions to be 0.5 seconds as a maximum
@@ -535,42 +535,6 @@ def long_running_app(environ, start_response):
             - datetime.fromisoformat(transaction["start_timestamp"])
         ).total_seconds()
         assert (
-            transaction_duration <= new_max_duration * 1.02
-        )  # we allow 2% margin for processing the request
-
-
-def test_long_running_transaction_timer_canceled(sentry_init, capture_events):
-    """
-    Test that the timer is canceled when the transaction is finished before the maximum duration.
-    """
-    # we allow transactions to be 0.5 seconds as a maximum
-    new_max_duration = 0.5
-
-    with mock.patch.object(
-        sentry_sdk.integrations.wsgi,
-        "MAX_TRANSACTION_DURATION_SECONDS",
-        new_max_duration,
-    ):
-        with mock.patch(
-            "sentry_sdk.integrations.wsgi.finish_running_transaction"
-        ) as mock_finish:
-
-            def generate_content():
-                # This response will take 0.3 seconds to generate
-                for _ in range(3):
-                    time.sleep(0.1)
-                    yield "ok"
-
-            def long_running_app(environ, start_response):
-                start_response("200 OK", [])
-                return generate_content()
-
-            sentry_init(send_default_pii=True, traces_sample_rate=1.0)
-            app = SentryWsgiMiddleware(long_running_app)
-
-            client = Client(app)
-            response = client.get("/")
-            _ = response.get_data()
-
-            first_call = mock_finish.mock_calls[0].kwargs
-            assert first_call["timer"] is not None  # if a timer is given, it will be cancelled
+            transaction_duration
+            <= new_max_duration * 1.02  # we allow 2% margin for processing the request
+        ), "Long running transaction has not been finished after a set maximum duration"