ref(transport): Make client work with sync flush changes

GH-4601

Author: srothh

sentry_sdk/client.py

@@ -1023,7 +1023,11 @@ async def _flush_async(
         self.session_flusher.flush()
         if self.log_batcher is not None:
             self.log_batcher.flush()
-        await self.transport.flush_async(timeout=timeout, callback=callback)  # type: ignore
+
+        # For async transport, flush() returns a Task that needs to be awaited
+        flush_task = self.transport.flush(timeout=timeout, callback=callback)  # type: ignore
+        if flush_task is not None:
+            await flush_task
 
     def __enter__(self) -> _Client:
         return self

sentry_sdk/transport.py

@@ -581,7 +581,7 @@ class AsyncHttpTransport(HttpTransportCore):
     def __init__(self: Self, options: Dict[str, Any]) -> None:
         super().__init__(options)
         # Requires event loop at init time
-        self._loop = asyncio.get_running_loop()
+        self.loop = asyncio.get_running_loop()
         self.background_tasks: set[asyncio.Task[None]] = set()
 
     def _get_header_value(self: Self, response: Any, header: str) -> Optional[str]:
@@ -679,10 +679,10 @@ def capture_envelope(self: Self, envelope: Envelope) -> None:
         except RuntimeError:
             # We are in a background thread, not running an event loop,
             # have to launch the task on the loop in a threadsafe way.
-            if self._loop and self._loop.is_running():
+            if self.loop and self.loop.is_running():
                 asyncio.run_coroutine_threadsafe(
                     self._capture_envelope(envelope),
-                    self._loop,
+                    self.loop,
                 )
             else:
                 # The event loop is no longer running
@@ -793,7 +793,7 @@ def kill(self: Self) -> Optional[asyncio.Task[None]]:  # type: ignore
         self.background_tasks.clear()
         try:
             # Return the pool cleanup task so caller can await it if needed
-            return self._loop.create_task(self._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

tests/test_transport.py

@@ -763,6 +763,47 @@ def close(self):
     assert seen == ["status_500"]
 
 
+def test_handle_request_error_basic_coverage(make_client, monkeypatch):
+    client = make_client()
+    transport = client.transport
+
+    monkeypatch.setattr(transport._worker, "submit", lambda fn: fn() or True)
+
+    # Track method calls
+    calls = []
+
+    def mock_on_dropped_event(reason):
+        calls.append(("on_dropped_event", reason))
+
+    def mock_record_lost_event(reason, data_category=None, item=None):
+        calls.append(("record_lost_event", reason, data_category, item))
+
+    monkeypatch.setattr(transport, "on_dropped_event", mock_on_dropped_event)
+    monkeypatch.setattr(transport, "record_lost_event", mock_record_lost_event)
+
+    # Test case 1: envelope is None
+    transport._handle_request_error(envelope=None, loss_reason="test_reason")
+
+    assert len(calls) == 2
+    assert calls[0] == ("on_dropped_event", "test_reason")
+    assert calls[1] == ("record_lost_event", "network_error", "error", None)
+
+    # Reset
+    calls.clear()
+
+    # Test case 2: envelope with items
+    envelope = Envelope()
+    envelope.add_item(mock.MagicMock())  # Simple mock item
+    envelope.add_item(mock.MagicMock())  # Another mock item
+
+    transport._handle_request_error(envelope=envelope, loss_reason="connection_error")
+
+    assert len(calls) == 3
+    assert calls[0] == ("on_dropped_event", "connection_error")
+    assert calls[1][0:2] == ("record_lost_event", "network_error")
+    assert calls[2][0:2] == ("record_lost_event", "network_error")
+
+
 @pytest.mark.asyncio
 @pytest.mark.skipif(not PY38, reason="Async transport requires Python 3.8+")
 async def test_async_transport_background_thread_capture(