Removed timer code, need to think about something better

Author: antonpirker

sentry_sdk/integrations/wsgi.py

@@ -1,6 +1,5 @@
 import sys
 from functools import partial
-from threading import Timer
 
 import sentry_sdk
 from sentry_sdk._werkzeug import get_host, _get_headers
@@ -124,18 +123,11 @@ def __call__(self, environ, start_response):
                             origin=self.span_origin,
                         )
 
-                    timer = None
                     if transaction is not None:
                         sentry_sdk.start_transaction(
                             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(
@@ -149,7 +141,7 @@ def __call__(self, environ, start_response):
                     except BaseException:
                         exc_info = sys.exc_info()
                         _capture_exception(exc_info)
-                        finish_running_transaction(current_scope, exc_info, timer)
+                        finish_running_transaction(current_scope, exc_info)
                         reraise(*exc_info)
 
         finally:
@@ -159,7 +151,6 @@ def __call__(self, environ, start_response):
             response=response,
             current_scope=current_scope,
             isolation_scope=scope,
-            timer=timer,
         )
 
 
@@ -255,20 +246,18 @@ class _ScopedResponse:
     - WSGI servers streaming responses interleaved from the same thread
     """
 
-    __slots__ = ("_response", "_current_scope", "_isolation_scope", "_timer")
+    __slots__ = ("_response", "_current_scope", "_isolation_scope")
 
     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]
     ):
         # type: (...) -> None
         self._response = response
         self._current_scope = current_scope
         self._isolation_scope = isolation_scope
-        self._timer = timer
 
     def __iter__(self):
         # type: () -> Iterator[bytes]
@@ -290,14 +279,14 @@ def __iter__(self):
         finally:
             with use_isolation_scope(self._isolation_scope):
                 with use_scope(self._current_scope):
-                    finish_running_transaction(timer=self._timer)
+                    finish_running_transaction()
 
     def close(self):
         # type: () -> None
         with use_isolation_scope(self._isolation_scope):
             with use_scope(self._current_scope):
                 try:
-                    finish_running_transaction(timer=self._timer)
+                    finish_running_transaction()
                     self._response.close()  # type: ignore
                 except AttributeError:
                     pass
@@ -346,18 +335,3 @@ def event_processor(event, hint):
         return event
 
     return event_processor
-
-
-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:
-        with use_isolation_scope(isolation_scope):
-            with use_scope(current_scope):
-                finish_running_transaction()
-    except AttributeError:
-        # transaction is not there anymore
-        pass

sentry_sdk/tracing_utils.py

@@ -37,7 +37,6 @@
     from types import FrameType
 
     from sentry_sdk._types import ExcInfo
-    from threading import Timer
 
 
 SENTRY_TRACE_REGEX = re.compile(
@@ -744,11 +743,8 @@ def get_current_span(scope=None):
     from sentry_sdk.tracing import Span
 
 
-def finish_running_transaction(scope=None, exc_info=None, timer=None):
-    # type: (Optional[sentry_sdk.Scope], Optional[ExcInfo], Optional[Timer]) -> None
-    if timer is not None:
-        timer.cancel()
-
+def finish_running_transaction(scope=None, exc_info=None):
+    # type: (Optional[sentry_sdk.Scope], Optional[ExcInfo]) -> None
     current_scope = scope or sentry_sdk.get_current_scope()
     if current_scope.transaction is not None and hasattr(
         current_scope.transaction, "_context_manager_state"

tests/integrations/wsgi/test_wsgi.py

@@ -537,40 +537,3 @@ def long_running_app(environ, start_response):
         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):
-    # 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_long_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)
-
-            events = capture_events()
-
-            client = Client(app)
-            response = client.get("/")
-            _ = response.get_data()
-
-            (transaction,) = events
-
-            mock_finish.assert_not_called()