ref(asyncio integration): Refactor code to avoid duplication

GH-4699

Author: srothh

sentry_sdk/integrations/asyncio.py

@@ -76,6 +76,33 @@ def _patched_close() -> None:
     loop._sentry_flush_patched = True  # type: ignore
 
 
+def _create_task_with_factory(
+    orig_task_factory: Any,
+    loop: asyncio.AbstractEventLoop,
+    coro: Coroutine[Any, Any, Any],
+    **kwargs: Any,
+) -> asyncio.Task[Any]:
+    task = None
+
+    # Trying to use user set task factory (if there is one)
+    if orig_task_factory:
+        task = orig_task_factory(loop, coro, **kwargs)
+
+    if task is None:
+        # The default task factory in `asyncio` does not have its own function
+        # but is just a couple of lines in `asyncio.base_events.create_task()`
+        # Those lines are copied here.
+
+        # WARNING:
+        # If the default behavior of the task creation in asyncio changes,
+        # this will break!
+        task = Task(coro, loop=loop, **kwargs)
+        if task._source_traceback:  # type: ignore
+            del task._source_traceback[-1]  # type: ignore
+
+    return task
+
+
 def patch_asyncio() -> None:
     orig_task_factory = None
     try:
@@ -92,15 +119,9 @@ def _sentry_task_factory(
             is_internal = is_internal_task()
 
             if is_internal:
-                task = None
-                if orig_task_factory:
-                    task = orig_task_factory(loop, coro, **kwargs)
-                if task is None:
-                    task = Task(coro, loop=loop, **kwargs)
-                    if task._source_traceback:  # type: ignore
-                        del task._source_traceback[-1]  # type: ignore
-
-                return task
+                return _create_task_with_factory(
+                    orig_task_factory, loop, coro, **kwargs
+                )
 
             async def _task_with_sentry_span_creation() -> Any:
                 result = None
@@ -119,25 +140,9 @@ async def _task_with_sentry_span_creation() -> Any:
 
                 return result
 
-            task = None
-
-            # Trying to use user set task factory (if there is one)
-            if orig_task_factory:
-                task = orig_task_factory(
-                    loop, _task_with_sentry_span_creation(), **kwargs
-                )
-
-            if task is None:
-                # The default task factory in `asyncio` does not have its own function
-                # but is just a couple of lines in `asyncio.base_events.create_task()`
-                # Those lines are copied here.
-
-                # WARNING:
-                # If the default behavior of the task creation in asyncio changes,
-                # this will break!
-                task = Task(_task_with_sentry_span_creation(), loop=loop, **kwargs)
-                if task._source_traceback:  # type: ignore
-                    del task._source_traceback[-1]  # type: ignore
+            task = _create_task_with_factory(
+                orig_task_factory, loop, _task_with_sentry_span_creation(), **kwargs
+            )
 
             # Set the task name to include the original coroutine's name
             try:

sentry_sdk/transport.py

@@ -806,7 +806,7 @@ def kill(self: Self) -> Optional[asyncio.Task[None]]:  # type: ignore
             try:
                 # Return the pool cleanup task so caller can await it if needed
                 with mark_sentry_task_internal():
-                    return self.loop.create_task(self._pool.aclose(), name="sentry_sdk_pool_aclose")  # type: ignore
+                    return self.loop.create_task(self._pool.aclose())  # type: ignore
             except RuntimeError:
                 logger.warning("Event loop not running, aborting kill.")
                 return None

sentry_sdk/worker.py

@@ -232,9 +232,7 @@ def start(self) -> None:
                 if self._queue is None:
                     self._queue = asyncio.Queue(maxsize=self._queue_size)
                 with mark_sentry_task_internal():
-                    self._task = self._loop.create_task(
-                        self._target(), name="sentry_sdk_async_worker"
-                    )
+                    self._task = self._loop.create_task(self._target())
                 self._task_for_pid = os.getpid()
             except RuntimeError:
                 # There is no event loop running
@@ -277,10 +275,7 @@ async def _wait_flush(self, timeout: float, callback: Optional[Any] = None) -> N
     def flush(self, timeout: float, callback: Optional[Any] = None) -> Optional[asyncio.Task[None]]:  # type: ignore[override]
         if self.is_alive and timeout > 0.0 and self._loop and self._loop.is_running():
             with mark_sentry_task_internal():
-                return self._loop.create_task(
-                    self._wait_flush(timeout, callback),
-                    name="sentry_sdk_async_worker_flush",
-                )
+                return self._loop.create_task(self._wait_flush(timeout, callback))
         return None
 
     def submit(self, callback: Callable[[], Any]) -> bool:
@@ -303,10 +298,7 @@ async def _target(self) -> None:
                 break
             # Firing tasks instead of awaiting them allows for concurrent requests
             with mark_sentry_task_internal():
-                task = asyncio.create_task(
-                    self._process_callback(callback),
-                    name="sentry_sdk_async_worker_process_callback",
-                )
+                task = asyncio.create_task(self._process_callback(callback))
             # Create a strong reference to the task so it can be cancelled on kill
             # and does not get garbage collected while running
             self._active_tasks.add(task)