Fix HTTP 404 error handling in urllib instrumentation REPLAY mode

When urllib raises HTTPError for 4xx/5xx responses, the instrumentation
now correctly replays this by raising HTTPError instead of returning a
normal MockHTTPResponse. This ensures application code catching HTTPError
behaves the same in RECORD and REPLAY modes.

- Add _raise_http_error_from_mock method to reconstruct HTTPError
- Check for errorName in _try_get_mock and raise appropriately
- Re-raise HTTPError/URLError exceptions to propagate correctly

Author: sohankshirsagar

drift/instrumentation/urllib/e2e-tests/src/app.py

@@ -328,6 +328,53 @@ def urlopen_with_data():
         return jsonify({"error": str(e)}), 500
 
 
+# Test: HTTP 404 error handling (BUG-EXPOSING TEST)
+@app.route("/test/http-404-error", methods=["GET"])
+def test_http_404_error():
+    """Test handling of HTTP 404 error responses.
+
+    When urlopen receives a 4xx/5xx response, it raises HTTPError which is
+    also a valid response object. This tests if the instrumentation correctly
+    handles this case.
+    """
+    from urllib.error import HTTPError as UrllibHTTPError
+    try:
+        with urlopen("https://httpbin.org/status/404", timeout=10) as response:
+            return jsonify({"status": response.status})
+    except UrllibHTTPError as e:
+        # HTTPError is also a response object - we can read its body
+        body = e.read().decode("utf-8") if e.fp else ""
+        return jsonify({
+            "error": True,
+            "code": e.code,
+            "reason": e.reason,
+            "body": body,
+        }), 200  # Return 200 since we handled the error
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Test: HTTP redirect handling (BUG-EXPOSING TEST)
+@app.route("/test/http-redirect", methods=["GET"])
+def test_http_redirect():
+    """Test HTTP redirect handling (301, 302, etc.).
+
+    urllib follows redirects automatically. This tests if the instrumentation
+    correctly handles redirect scenarios.
+    """
+    try:
+        # httpbin.org/redirect/n redirects n times before returning 200
+        with urlopen("https://httpbin.org/redirect/2", timeout=10) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            return jsonify({
+                "final_url": response.geturl(),
+                "status": response.status,
+                "data": data,
+            })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
 if __name__ == "__main__":
     sdk.mark_app_as_ready()
     app.run(host="0.0.0.0", port=8000, debug=False)

drift/instrumentation/urllib/e2e-tests/src/test_requests.py

@@ -54,4 +54,11 @@
     # urlopen with data parameter
     make_request("POST", "/api/urlopen-with-data")
 
+    # Bug-exposing tests (these tests expose bugs in the instrumentation)
+    # HTTP 404 error handling - tests HTTPError replay
+    make_request("GET", "/test/http-404-error")
+
+    # HTTP redirect handling - tests geturl() after redirects
+    make_request("GET", "/test/http-redirect")
+
     print_request_summary()

drift/instrumentation/urllib/instrumentation.py

@@ -654,6 +654,9 @@ def _try_get_mock(
 
         Returns:
             Mocked response object if found, None otherwise
+
+        Raises:
+            urllib.error.HTTPError: If the recorded response was an HTTPError
         """
         try:
             parsed_url = urlparse(url)
@@ -729,9 +732,22 @@ def _try_get_mock(
             if mock_response_output.response is None:
                 logger.debug(f"Mock found but response data is None for {method} {url}")
                 return None
-            return self._create_mock_response(mock_response_output.response, url)
+
+            # Check if the recorded response was an error (HTTPError, URLError, etc.)
+            response_data = mock_response_output.response
+            error_name = response_data.get("errorName")
+
+            if error_name == "HTTPError":
+                # The original request raised HTTPError - we need to raise it too
+                self._raise_http_error_from_mock(response_data, url)
+
+            return self._create_mock_response(response_data, url)
 
         except Exception as e:
+            # Re-raise HTTPError (and other urllib errors) so they propagate correctly
+            from urllib.error import HTTPError, URLError
+            if isinstance(e, (HTTPError, URLError)):
+                raise
             logger.error(f"Error getting mock for {method} {url}: {e}")
             return None
 
@@ -785,6 +801,49 @@ def _create_mock_response(self, mock_data: dict[str, Any], url: str) -> MockHTTP
             url=url,
         )
 
+    def _raise_http_error_from_mock(self, mock_data: dict[str, Any], url: str) -> None:
+        """Raise an HTTPError from mocked error response data.
+
+        When the original request resulted in an HTTPError (4xx/5xx status codes),
+        we need to raise the same error during replay so application code that
+        catches HTTPError behaves the same way.
+
+        Args:
+            mock_data: Mock response data containing errorName and errorMessage
+            url: Request URL
+
+        Raises:
+            urllib.error.HTTPError: Always raises this exception
+        """
+        from email.message import Message
+        from urllib.error import HTTPError
+
+        error_message = mock_data.get("errorMessage", "")
+
+        # Parse status code and reason from error message
+        # Format: "HTTP Error 404: NOT FOUND"
+        status_code = 500  # Default
+        reason = "Internal Server Error"
+
+        if error_message.startswith("HTTP Error "):
+            try:
+                # Extract "404: NOT FOUND" part
+                parts = error_message[len("HTTP Error "):].split(":", 1)
+                status_code = int(parts[0].strip())
+                if len(parts) > 1:
+                    reason = parts[1].strip()
+            except (ValueError, IndexError):
+                pass
+
+        # Create empty headers (HTTPError requires headers object)
+        headers = Message()
+
+        # Create empty body
+        body_fp = BytesIO(b"")
+
+        logger.debug(f"Raising HTTPError {status_code} for {url} (replayed from recording)")
+        raise HTTPError(url, status_code, reason, headers, body_fp)
+
     def _finalize_span(
         self,
         span: Span,