feat: add support for async response log (#1733)

* feat: add support for async response log

* fix whitespace

* add await

* add code coverage

* fix lint

* fix lint issues

* address PR feedback

* address PR feedback

* link issue

Author: ohmayr

google/auth/_helpers.py

@@ -443,15 +443,33 @@ def _parse_response(response: Any) -> Any:
         The parsed response. If the response contains valid JSON, the
         decoded JSON object (e.g., a dictionary or list) is returned.
         If the response does not have a `json()` method or if the JSON
-        decoding fails, the original response object is returned.
+        decoding fails, None is returned.
     """
     try:
         json_response = response.json()
         return json_response
-    except AttributeError:
-        return response
-    except json.JSONDecodeError:
-        return response
+    except Exception:
+        # TODO(https://github.com/googleapis/google-auth-library-python/issues/1744):
+        # Parse and return response payload as json based on different content types.
+        return None
+
+
+def _response_log_base(logger: logging.Logger, parsed_response: Any) -> None:
+    """
+    Logs a parsed HTTP response at the DEBUG level.
+
+    This internal helper function takes a parsed response and logs it
+    using the provided logger. It also applies a hashing function to
+    potentially sensitive information before logging.
+
+    Args:
+        logger: The logging.Logger instance to use for logging.
+        parsed_response: The parsed HTTP response object (e.g., a dictionary,
+            list, or the original response if parsing failed).
+    """
+
+    logged_response = _hash_sensitive_info(parsed_response)
+    logger.debug("Response received...", extra={"httpResponse": logged_response})
 
 
 def response_log(logger: logging.Logger, response: Any) -> None:
@@ -464,5 +482,4 @@ def response_log(logger: logging.Logger, response: Any) -> None:
     """
     if is_logging_enabled(logger):
         json_response = _parse_response(response)
-        logged_response = _hash_sensitive_info(json_response)
-        logger.debug("Response received...", extra={"httpResponse": logged_response})
+        _response_log_base(logger, json_response)

google/auth/aio/_helpers.py

@@ -0,0 +1,57 @@
+# Copyright 2025 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helper functions for commonly used utilities."""
+
+
+import logging
+from typing import Any
+
+from google.auth import _helpers
+
+
+async def _parse_response_async(response: Any) -> Any:
+    """
+    Parses an async response, attempting to decode JSON.
+
+    Args:
+        response: The response object to parse. This can be any type, but
+            it is expected to have a `json()` method if it contains JSON.
+
+    Returns:
+        The parsed response. If the response contains valid JSON, the
+        decoded JSON object (e.g., a dictionary) is returned.
+        If the response does not have a `json()` method or if the JSON
+        decoding fails, None is returned.
+    """
+    try:
+        json_response = await response.json()
+        return json_response
+    except Exception:
+        # TODO(https://github.com/googleapis/google-auth-library-python/issues/1745):
+        # Parse and return response payload as json based on different content types.
+        return None
+
+
+async def response_log_async(logger: logging.Logger, response: Any) -> None:
+    """
+    Logs an Async HTTP response at the DEBUG level if logging is enabled.
+
+    Args:
+        logger: The logging.Logger instance to use.
+        response: The HTTP response object to log.
+    """
+    if _helpers.is_logging_enabled(logger):
+        json_response = await _parse_response_async(response)
+        _helpers._response_log_base(logger, json_response)

google/auth/aio/transport/aiohttp.py

@@ -28,6 +28,7 @@
 
 from google.auth import _helpers
 from google.auth import exceptions
+from google.auth.aio import _helpers as _helpers_async
 from google.auth.aio import transport
 
 _LOGGER = logging.getLogger(__name__)
@@ -167,7 +168,7 @@ async def __call__(
                 timeout=client_timeout,
                 **kwargs,
             )
-            # TODO(https://github.com/googleapis/google-auth-library-python/issues/1697): Add response log.
+            await _helpers_async.response_log_async(_LOGGER, response)
             return Response(response)
 
         except aiohttp.ClientError as caught_exc:

google/auth/transport/_aiohttp_requests.py

@@ -30,6 +30,7 @@
 from google.auth import _helpers
 from google.auth import exceptions
 from google.auth import transport
+from google.auth.aio import _helpers as _helpers_async
 from google.auth.transport import requests
 
 
@@ -191,7 +192,7 @@ async def __call__(
             response = await self.session.request(
                 method, url, data=body, headers=headers, timeout=timeout, **kwargs
             )
-            # TODO(https://github.com/googleapis/google-auth-library-python/issues/1697): Add response log.
+            await _helpers_async.response_log_async(_LOGGER, response)
             return _CombinedResponse(response)
 
         except aiohttp.ClientError as caught_exc:

tests/aio/test__helpers.py

@@ -0,0 +1,94 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import logging
+from unittest import mock
+
+import pytest  # type: ignore
+
+from google.auth.aio import _helpers
+
+
+@pytest.fixture
+def logger():
+    """Provides a basic logger instance for testing."""
+    return logging.getLogger(__name__)
+
+
+@pytest.mark.asyncio
+async def test_response_log_debug_enabled(logger, caplog):
+    logger.setLevel(logging.DEBUG)
+    with mock.patch("google.auth._helpers.CLIENT_LOGGING_SUPPORTED", True):
+        await _helpers.response_log_async(logger, {"payload": None})
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.message == "Response received..."
+    assert record.httpResponse == "<class 'NoneType'>"
+
+
+@pytest.mark.asyncio
+async def test_response_log_debug_disabled(logger, caplog):
+    logger.setLevel(logging.INFO)
+    with mock.patch("google.auth._helpers.CLIENT_LOGGING_SUPPORTED", True):
+        await _helpers.response_log_async(logger, "another_response")
+    assert "Response received..." not in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_response_log_debug_enabled_response_json(logger, caplog):
+    class MockResponse:
+        async def json(self):
+            return {"key1": "value1", "key2": "value2", "key3": "value3"}
+
+    response = MockResponse()
+    logger.setLevel(logging.DEBUG)
+    with mock.patch("google.auth._helpers.CLIENT_LOGGING_SUPPORTED", True):
+        await _helpers.response_log_async(logger, response)
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.message == "Response received..."
+    assert record.httpResponse == {"key1": "value1", "key2": "value2", "key3": "value3"}
+
+
+@pytest.mark.asyncio
+async def test_parse_response_async_json_valid():
+    class MockResponse:
+        async def json(self):
+            return {"data": "test"}
+
+    response = MockResponse()
+    expected = {"data": "test"}
+    assert await _helpers._parse_response_async(response) == expected
+
+
+@pytest.mark.asyncio
+async def test_parse_response_async_json_invalid():
+    class MockResponse:
+        def json(self):
+            raise json.JSONDecodeError("msg", "doc", 0)
+
+    response = MockResponse()
+    assert await _helpers._parse_response_async(response) is None
+
+
+@pytest.mark.asyncio
+async def test_parse_response_async_no_json_method():
+    response = "plain text"
+    assert await _helpers._parse_response_async(response) is None
+
+
+@pytest.mark.asyncio
+async def test_parse_response_async_none():
+    assert await _helpers._parse_response_async(None) is None

tests/test__helpers.py

@@ -398,7 +398,7 @@ def test_response_log_debug_enabled(logger, caplog):
     assert len(caplog.records) == 1
     record = caplog.records[0]
     assert record.message == "Response received..."
-    assert record.httpResponse == {"payload": None}
+    assert record.httpResponse == "<class 'NoneType'>"
 
 
 def test_response_log_debug_disabled(logger, caplog):
@@ -518,12 +518,12 @@ def json(self):
             raise json.JSONDecodeError("msg", "doc", 0)
 
     response = MockResponse()
-    assert _helpers._parse_response(response) == response
+    assert _helpers._parse_response(response) is None
 
 
 def test_parse_response_no_json_method():
     response = "plain text"
-    assert _helpers._parse_response(response) == "plain text"
+    assert _helpers._parse_response(response) is None
 
 
 def test_parse_response_none():