Clarify LineTooLong error messages with context label

The `LineTooLong` exception now accepts an optional `context` parameter
describing which part of the HTTP message exceeded the size limit
(e.g. `"request URL"`, `"status reason phrase"`, `"header field name"`,
`"header field value"`, `"request/status line"`, `"trailer line"`,
`"chunk size line"`, `"header line with continuations"`, or
`"stream until separator"`). Every `LineTooLong` call site in the pure-Python
parser, the Cython parser, and `StreamReader.readuntil` now passes a
descriptive context.

Fixes the confusing "Status line is too long" error reported in #7177
when the actual issue is a too-long URL.

Co-authored-by: Claude <[email protected]>

Author: yuj

CHANGES/7177.bugfix.rst

@@ -0,0 +1,6 @@
+Improved the :exc:`~aiohttp.http_exceptions.LineTooLong` error message to
+describe which part of the HTTP message exceeded the limit (e.g. the request
+URL, status reason phrase, header field name/value, request/status line, or
+trailer). Previously, every overflow reported a generic ``"when reading:"``
+prefix, which was confusing when only the URL was too long but the message was
+historically labeled as a status-line overflow -- by :user:`Ricardo-M-L`.

aiohttp/_http_parser.pyx

@@ -773,8 +773,10 @@ cdef int cb_on_url(cparser.llhttp_t* parser,
     cdef HttpParser pyparser = <HttpParser>parser.data
     try:
         if length > pyparser._max_line_size:
-            status = pyparser._buf + at[:length]
-            raise LineTooLong(status[:100] + b"...", pyparser._max_line_size)
+            url = pyparser._buf + at[:length]
+            raise LineTooLong(
+                url[:100] + b"...", pyparser._max_line_size, "request URL"
+            )
         extend(pyparser._buf, at, length)
     except BaseException as ex:
         pyparser._last_error = ex
@@ -789,7 +791,11 @@ cdef int cb_on_status(cparser.llhttp_t* parser,
     try:
         if length > pyparser._max_line_size:
             reason = pyparser._buf + at[:length]
-            raise LineTooLong(reason[:100] + b"...", pyparser._max_line_size)
+            raise LineTooLong(
+                reason[:100] + b"...",
+                pyparser._max_line_size,
+                "status reason phrase",
+            )
         extend(pyparser._buf, at, length)
     except BaseException as ex:
         pyparser._last_error = ex
@@ -807,7 +813,11 @@ cdef int cb_on_header_field(cparser.llhttp_t* parser,
         size = len(pyparser._raw_name) + length
         if size > pyparser._max_field_size:
             name = pyparser._raw_name + at[:length]
-            raise LineTooLong(name[:100] + b"...", pyparser._max_field_size)
+            raise LineTooLong(
+                name[:100] + b"...",
+                pyparser._max_field_size,
+                "header field name",
+            )
         pyparser._header_name_size = size
         pyparser._on_header_field(at, length)
     except BaseException as ex:
@@ -825,7 +835,11 @@ cdef int cb_on_header_value(cparser.llhttp_t* parser,
         size = len(pyparser._raw_value) + length
         if pyparser._header_name_size + size > pyparser._max_field_size:
             value = pyparser._raw_value + at[:length]
-            raise LineTooLong(value[:100] + b"...", pyparser._max_field_size)
+            raise LineTooLong(
+                value[:100] + b"...",
+                pyparser._max_field_size,
+                "header field value",
+            )
         pyparser._on_header_value(at, length)
     except BaseException as ex:
         pyparser._last_error = ex

aiohttp/http_exceptions.py

@@ -74,9 +74,13 @@ class ContentLengthError(PayloadEncodingError):
 
 
 class LineTooLong(BadHttpMessage):
-    def __init__(self, line: bytes, limit: int) -> None:
-        super().__init__(f"Got more than {limit} bytes when reading: {line!r}.")
-        self.args = (line, limit)
+    def __init__(
+        self, line: bytes, limit: int, context: str = "line"
+    ) -> None:
+        super().__init__(
+            f"Got more than {limit} bytes when reading {context}: {line!r}."
+        )
+        self.args = (line, limit, context)
 
 
 class InvalidHeader(BadHttpMessage):

aiohttp/http_parser.py

@@ -207,7 +207,9 @@ def parse_headers(
                     if header_length > self.max_field_size:
                         header_line = bname + b": " + b"".join(bvalue_lst)
                         raise LineTooLong(
-                            header_line[:100] + b"...", self.max_field_size
+                            header_line[:100] + b"...",
+                            self.max_field_size,
+                            "header line with continuations",
                         )
                     bvalue_lst.append(line)
 
@@ -354,7 +356,13 @@ def feed_data(
                     if SEP == b"\n":  # For lax response parsing
                         line = line.rstrip(b"\r")
                     if len(line) > max_line_length:
-                        raise LineTooLong(line[:100] + b"...", max_line_length)
+                        raise LineTooLong(
+                            line[:100] + b"...",
+                            max_line_length,
+                            "request/status line"
+                            if not self._lines
+                            else "header line",
+                        )
 
                     self._lines.append(line)
                     # After processing the status/request line, everything is a header.
@@ -487,7 +495,11 @@ def get_content_length() -> int | None:
                 else:
                     self._tail = data[start_pos:]
                     if len(self._tail) > self.max_line_size:
-                        raise LineTooLong(self._tail[:100] + b"...", self.max_line_size)
+                        raise LineTooLong(
+                            self._tail[:100] + b"...",
+                            self.max_line_size,
+                            "request/status line",
+                        )
                     data = EMPTY
                     break
 
@@ -922,7 +934,11 @@ def feed_data(
                         max_line_length = self._max_field_size
                     if len(self._chunk_tail) > max_line_length:
                         raise LineTooLong(
-                            self._chunk_tail[:100] + b"...", max_line_length
+                            self._chunk_tail[:100] + b"...",
+                            max_line_length,
+                            "chunk size line"
+                            if self._chunk != ChunkState.PARSE_TRAILERS
+                            else "trailer line",
                         )
 
                 chunk = self._chunk_tail + chunk
@@ -1020,7 +1036,11 @@ def feed_data(
                         line = line.rstrip(b"\r")
 
                     if len(line) > self._max_field_size:
-                        raise LineTooLong(line[:100] + b"...", self._max_field_size)
+                        raise LineTooLong(
+                            line[:100] + b"...",
+                            self._max_field_size,
+                            "trailer line",
+                        )
 
                     self._trailer_lines.append(line)
 

aiohttp/streams.py

@@ -395,7 +395,9 @@ async def readuntil(
                     not_enough = False
 
                 if chunk_size > max_size:
-                    raise LineTooLong(chunk[:100] + b"...", max_size)
+                    raise LineTooLong(
+                        chunk[:100] + b"...", max_size, "stream until separator"
+                    )
 
             if self._eof:
                 break

tests/test_http_exceptions.py

@@ -79,7 +79,16 @@ class TestLineTooLong:
     def test_ctor(self) -> None:
         err = http_exceptions.LineTooLong(b"spam", 10)
         assert err.code == 400
-        assert err.message == "Got more than 10 bytes when reading: b'spam'."
+        assert err.message == "Got more than 10 bytes when reading line: b'spam'."
+        assert err.headers is None
+
+    def test_ctor_with_context(self) -> None:
+        err = http_exceptions.LineTooLong(b"spam", 10, "request URL")
+        assert err.code == 400
+        assert (
+            err.message
+            == "Got more than 10 bytes when reading request URL: b'spam'."
+        )
         assert err.headers is None
 
     def test_pickle(self) -> None:
@@ -89,20 +98,35 @@ def test_pickle(self) -> None:
             pickled = pickle.dumps(err, proto)
             err2 = pickle.loads(pickled)
             assert err2.code == 400
-            assert err2.message == ("Got more than 10 bytes when reading: b'spam'.")
+            assert err2.message == (
+                "Got more than 10 bytes when reading line: b'spam'."
+            )
             assert err2.headers is None
             assert err2.foo == "bar"
 
+    def test_pickle_with_context(self) -> None:
+        err = http_exceptions.LineTooLong(
+            line=b"spam", limit=10, context="request URL"
+        )
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            pickled = pickle.dumps(err, proto)
+            err2 = pickle.loads(pickled)
+            assert err2.message == (
+                "Got more than 10 bytes when reading request URL: b'spam'."
+            )
+
     def test_str(self) -> None:
         err = http_exceptions.LineTooLong(line=b"spam", limit=10)
-        expected = "400, message:\n  Got more than 10 bytes when reading: b'spam'."
+        expected = (
+            "400, message:\n  Got more than 10 bytes when reading line: b'spam'."
+        )
         assert str(err) == expected
 
     def test_repr(self) -> None:
         err = http_exceptions.LineTooLong(line=b"spam", limit=10)
         assert repr(err) == (
             '<LineTooLong: 400, message="Got more than '
-            "10 bytes when reading: b'spam'.\">"
+            "10 bytes when reading line: b'spam'.\">"
         )
 
 

tests/test_http_parser.py

@@ -1552,6 +1552,20 @@ def test_http_request_max_status_line(parser: HttpRequestParser, size: int) -> N
         parser.feed_data(b"GET /path" + path + b" HTTP/1.1\r\n\r\n")
 
 
+def test_http_request_max_status_line_mentions_request_line(
+    parser: HttpRequestParser,
+) -> None:
+    path = b"t" * 8186
+    with pytest.raises(http_exceptions.LineTooLong) as exc_info:
+        parser.feed_data(b"GET /path" + path + b" HTTP/1.1\r\n\r\n")
+    # Error message must describe what overflowed (not "status line" when
+    # the request line is too long). See gh-7177.
+    assert (
+        "request URL" in exc_info.value.message
+        or "request/status line" in exc_info.value.message
+    )
+
+
 def test_http_request_max_status_line_under_limit(parser: HttpRequestParser) -> None:
     path = b"t" * 8172
     messages, upgraded, tail = parser.feed_data(