perf(models): guard debug log evaluation with isEnabledFor

Co-authored-by: George Weale <gweale@google.com>
PiperOrigin-RevId: 917411239

Author: GWeale

src/google/adk/models/google_llm.py

@@ -252,7 +252,8 @@ async def generate_content_async(
         aggregator = StreamingResponseAggregator()
         async with Aclosing(responses) as agen:
           async for response in agen:
-            logger.debug(_build_response_log(response))
+            if logger.isEnabledFor(logging.DEBUG):
+              logger.debug(_build_response_log(response))
             async with Aclosing(
                 aggregator.process_response(response)
             ) as aggregator_gen:
@@ -274,7 +275,8 @@ async def generate_content_async(
             config=llm_request.config,
         )
         logger.info('Response received from the model.')
-        logger.debug(_build_response_log(response))
+        if logger.isEnabledFor(logging.DEBUG):
+          logger.debug(_build_response_log(response))
 
         llm_response = LlmResponse.create(response)
         if cache_metadata:

src/google/adk/models/lite_llm.py

@@ -2224,7 +2224,8 @@ async def generate_content_async(
 
     self._maybe_append_user_content(llm_request)
     _append_fallback_user_content_if_missing(llm_request)
-    logger.debug(_build_request_log(llm_request))
+    if logger.isEnabledFor(logging.DEBUG):
+      logger.debug(_build_request_log(llm_request))
 
     effective_model = llm_request.model or self.model
     messages, tools, response_format, generation_params = (

tests/unittests/models/test_google_llm.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
 import os
 import sys
 from typing import Optional
@@ -2263,3 +2264,96 @@ async def __aexit__(self, *args):
       # Verify the final speech_config is still None
       assert config_arg.speech_config is None
       assert isinstance(connection, GeminiLlmConnection)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "log_level,should_call",
+    [
+        (logging.WARNING, False),
+        (logging.INFO, False),
+        (logging.DEBUG, True),
+    ],
+)
+async def test_generate_content_async_skips_response_log_build_above_debug(
+    gemini_llm,
+    llm_request,
+    generate_content_response,
+    log_level,
+    should_call,
+):
+  gemini_logger = logging.getLogger("google_adk.google.adk.models.google_llm")
+  original_level = gemini_logger.level
+  gemini_logger.setLevel(log_level)
+  try:
+    with mock.patch(
+        "google.adk.models.google_llm._build_response_log",
+        return_value="log",
+    ) as mock_build:
+      with mock.patch.object(gemini_llm, "api_client") as mock_client:
+
+        async def mock_coro():
+          return generate_content_response
+
+        mock_client.aio.models.generate_content.return_value = mock_coro()
+
+        async for _ in gemini_llm.generate_content_async(
+            llm_request, stream=False
+        ):
+          pass
+
+      assert mock_build.called is should_call
+  finally:
+    gemini_logger.setLevel(original_level)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "log_level,should_call",
+    [
+        (logging.WARNING, False),
+        (logging.INFO, False),
+        (logging.DEBUG, True),
+    ],
+)
+async def test_generate_content_async_stream_skips_response_log_build_above_debug(
+    gemini_llm, llm_request, log_level, should_call
+):
+  mock_responses = [
+      types.GenerateContentResponse(
+          candidates=[
+              types.Candidate(
+                  content=Content(
+                      role="model", parts=[Part.from_text(text="hi")]
+                  ),
+                  finish_reason=types.FinishReason.STOP,
+              )
+          ]
+      ),
+  ]
+
+  gemini_logger = logging.getLogger("google_adk.google.adk.models.google_llm")
+  original_level = gemini_logger.level
+  gemini_logger.setLevel(log_level)
+  try:
+    with mock.patch(
+        "google.adk.models.google_llm._build_response_log",
+        return_value="log",
+    ) as mock_build:
+      with mock.patch.object(gemini_llm, "api_client") as mock_client:
+
+        async def mock_coro():
+          return MockAsyncIterator(mock_responses)
+
+        mock_client.aio.models.generate_content_stream.return_value = (
+            mock_coro()
+        )
+
+        async for _ in gemini_llm.generate_content_async(
+            llm_request, stream=True
+        ):
+          pass
+
+      assert mock_build.called is should_call
+  finally:
+    gemini_logger.setLevel(original_level)

tests/unittests/models/test_litellm.py

@@ -24,6 +24,7 @@
 from unittest.mock import AsyncMock
 from unittest.mock import MagicMock
 from unittest.mock import Mock
+from unittest.mock import patch
 import warnings
 
 from google.adk.models.lite_llm import _append_fallback_user_content_if_missing
@@ -4954,3 +4955,34 @@ async def test_content_to_message_param_anthropic_no_signature_falls_back():
   # Falls back to reasoning_content when no signatures present
   assert result.get("reasoning_content") == "thinking without sig"
   assert "thinking_blocks" not in result
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "log_level,should_call",
+    [
+        (logging.WARNING, False),
+        (logging.INFO, False),
+        (logging.DEBUG, True),
+    ],
+)
+async def test_generate_content_async_skips_request_log_build_above_debug(
+    mock_acompletion, lite_llm_instance, log_level, should_call
+):
+  del mock_acompletion  # unused; lite_llm_instance is wired to it
+  litellm_logger = logging.getLogger("google_adk.google.adk.models.lite_llm")
+  original_level = litellm_logger.level
+  litellm_logger.setLevel(log_level)
+  try:
+    with patch(
+        "google.adk.models.lite_llm._build_request_log",
+        return_value="log",
+    ) as mock_build:
+      async for _ in lite_llm_instance.generate_content_async(
+          LLM_REQUEST_WITH_FUNCTION_DECLARATION
+      ):
+        pass
+
+      assert mock_build.called is should_call
+  finally:
+    litellm_logger.setLevel(original_level)