fix(telemetry): mark failed tool spans as errors and fix provider naming

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

Author: GWeale

src/google/adk/telemetry/_instrumentation.py

@@ -209,6 +209,7 @@ async def record_tool_execution(
   """Unified context manager for consolidated tool execution telemetry."""
   start_time = time.monotonic()
   caught_error: Exception | None = None
+  detected_error_type: str | None = None
   span: trace.Span | None = None
   span_name = f"execute_tool {tool.name}"
   try:
@@ -221,6 +222,7 @@ async def record_tool_execution(
         caught_error = e
         raise
       finally:
+        detected_error_type = tel_ctx.error_type
         response_event = (
             tel_ctx.function_response_event if caught_error is None else None
         )
@@ -241,6 +243,7 @@ async def record_tool_execution(
           agent_name=agent.name,
           elapsed_s=_metrics.get_elapsed_s(span, start_time),
           error=caught_error,
+          error_type=detected_error_type,
       )
     except Exception:  # pylint: disable=broad-exception-caught
       logger.exception(

src/google/adk/telemetry/_metrics.py

@@ -188,15 +188,28 @@ def record_tool_execution_duration(
     agent_name: str,
     elapsed_s: float,
     error: Exception | None = None,
+    error_type: str | None = None,
 ):
-  """Records the duration of the tool execution."""
+  """Records the duration of the tool execution.
+
+  Args:
+    tool_name: Name of the tool that ran.
+    tool_type: Class name of the tool that ran.
+    agent_name: Name of the agent that ran the tool.
+    elapsed_s: Duration of the tool execution, in seconds.
+    error: The exception raised by the tool, if any.
+    error_type: An error type detected from a tool response that reported a
+      failure without raising. Ignored when `error` is also set.
+  """
   attrs = {
       gen_ai_attributes.GEN_AI_AGENT_NAME: agent_name,
       gen_ai_attributes.GEN_AI_TOOL_NAME: tool_name,
       gen_ai_attributes.GEN_AI_TOOL_TYPE: tool_type,
   }
   if error is not None:
     attrs[error_attributes.ERROR_TYPE] = tracing.resolve_error_type(error)
+  elif error_type is not None:
+    attrs[error_attributes.ERROR_TYPE] = error_type
   _tool_execution_duration.record(elapsed_s, attributes=attrs)
 
 
@@ -212,7 +225,9 @@ def record_client_operation_duration(
   attrs = {
       gen_ai_attributes.GEN_AI_AGENT_NAME: agent_name,
       gen_ai_attributes.GEN_AI_OPERATION_NAME: "generate_content",
-      gen_ai_attributes.GEN_AI_PROVIDER_NAME: _get_provider_name(),
+      gen_ai_attributes.GEN_AI_PROVIDER_NAME: _get_provider_name(
+          llm_request.model
+      ),
   }
   if llm_request.model:
     attrs[gen_ai_attributes.GEN_AI_REQUEST_MODEL] = llm_request.model
@@ -262,7 +277,9 @@ def record_client_token_usage(
   base_attrs = {
       gen_ai_attributes.GEN_AI_AGENT_NAME: agent_name,
       gen_ai_attributes.GEN_AI_OPERATION_NAME: "generate_content",
-      gen_ai_attributes.GEN_AI_PROVIDER_NAME: _get_provider_name(),
+      gen_ai_attributes.GEN_AI_PROVIDER_NAME: _get_provider_name(
+          llm_request.model
+      ),
   }
   if llm_request.model:
     base_attrs[gen_ai_attributes.GEN_AI_REQUEST_MODEL] = llm_request.model
@@ -280,8 +297,8 @@ def record_client_token_usage(
     _client_token_usage.record(output_token_count, attributes=output_attrs)
 
 
-def _get_provider_name() -> str:
-  return tracing._guess_gemini_system_name()
+def _get_provider_name(model: str | None) -> str:
+  return tracing._resolve_gen_ai_system_name(model)
 
 
 def get_elapsed_s(

src/google/adk/telemetry/tracing.py

@@ -29,6 +29,7 @@
 from contextlib import asynccontextmanager
 from contextlib import contextmanager
 import logging
+import re
 from typing import Final
 from typing import TYPE_CHECKING
 
@@ -54,11 +55,14 @@
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv.schemas import Schemas
 from opentelemetry.trace import Span
+from opentelemetry.trace import Status
+from opentelemetry.trace import StatusCode
 from opentelemetry.util.types import AttributeValue
 from typing_extensions import deprecated
 
 from .. import version
 from ..utils.env_utils import is_enterprise_mode_enabled
+from ..utils.model_name_utils import extract_model_name
 from ..utils.model_name_utils import is_gemini_model
 from ._experimental_semconv import maybe_log_completion_details
 from ._experimental_semconv import set_operation_details_attributes_from_request
@@ -98,6 +102,7 @@
   from ..models.llm_request import LlmRequest
   from ..models.llm_response import LlmResponse
   from ..tools.base_tool import BaseTool
+  from ..workflow._base_node import BaseNode
 
 tracer = trace.get_tracer(
     instrumenting_module_name="gcp.vertex.agent",
@@ -212,10 +217,19 @@ def trace_tool_call(
   ):
     span.set_attribute(GEN_AI_AGENT_NAME, agent.name)
 
+  failure_type: str | None = None
   if error is not None:
-    span.set_attribute(ERROR_TYPE, resolve_error_type(error))
+    failure_type = resolve_error_type(error)
+    span.record_exception(error)
   elif error_type is not None:
-    span.set_attribute(ERROR_TYPE, error_type)
+    failure_type = error_type
+  if failure_type is not None:
+    span.set_attribute(ERROR_TYPE, failure_type)
+    # Without an explicit error status the span renders as successful, which
+    # hides tools that reported a failure as a response dict instead of
+    # raising. The description repeats the type rather than the error message
+    # so no tool content lands in an attribute the content toggle cannot gate.
+    span.set_status(Status(StatusCode.ERROR, failure_type))
 
   # Special case for client side association with a remote tool call
   if (
@@ -742,14 +756,7 @@ def _use_extra_generate_content_attributes(
 
 
 def _is_gemini_agent(agent: BaseAgent) -> bool:
-  from ..agents.llm_agent import LlmAgent
-
-  if not isinstance(agent, LlmAgent):
-    return False
-
-  model = agent.model if agent.model != "" else agent._default_model
-  model_name = model if isinstance(model, str) else model.model
-  return is_gemini_model(model_name)
+  return is_gemini_model(_agent_model_name(agent))
 
 
 def _set_common_generate_content_attributes(
@@ -770,10 +777,11 @@ def _use_native_generate_content_span_stable_semconv(
     telemetry_config: TelemetryConfig | None = None,
 ) -> Iterator[GenerateContentSpan]:
   telemetry_config = telemetry_config or TelemetryConfig()
+  system_name = _resolve_gen_ai_system_name(llm_request.model)
   with tracer.start_as_current_span(
       f"generate_content {llm_request.model or ''}"
   ) as span:
-    span.set_attribute(GEN_AI_SYSTEM, _guess_gemini_system_name())
+    span.set_attribute(GEN_AI_SYSTEM, system_name)
     _set_common_generate_content_attributes(
         span, llm_request, common_attributes
     )
@@ -783,10 +791,10 @@ def _use_native_generate_content_span_stable_semconv(
         LogRecord(
             event_name=GEN_AI_SYSTEM_MESSAGE_EVENT,
             body=system_message_body(llm_request, telemetry_config),
-            attributes={GEN_AI_SYSTEM: _guess_gemini_system_name()},
+            attributes={GEN_AI_SYSTEM: system_name},
         )
     )
-    user_message_attributes = {GEN_AI_SYSTEM: _guess_gemini_system_name()}
+    user_message_attributes = {GEN_AI_SYSTEM: system_name}
     if (
         telemetry_config.should_add_content_to_logs
         and log_only_common_attributes
@@ -871,7 +879,9 @@ def trace_generate_content_result(span: Span | None, llm_response: LlmResponse):
       LogRecord(
           event_name=GEN_AI_CHOICE_EVENT,
           body=choice_body(llm_response, TelemetryConfig()),
-          attributes={GEN_AI_SYSTEM: _guess_gemini_system_name()},
+          attributes={
+              GEN_AI_SYSTEM: _inference_system_name(None, llm_response)
+          },
       )
   )
 
@@ -916,7 +926,11 @@ def trace_inference_result(
             body=choice_body(
                 llm_response, telemetry_config or TelemetryConfig()
             ),
-            attributes={GEN_AI_SYSTEM: _guess_gemini_system_name()},
+            attributes={
+                GEN_AI_SYSTEM: _inference_system_name(
+                    invocation_context, llm_response
+                )
+            },
         )
     )
 
@@ -927,3 +941,78 @@ def _guess_gemini_system_name() -> str:
       if is_enterprise_mode_enabled()
       else GenAiSystemValues.GEMINI.name.lower()
   )
+
+
+# Anthropic models reach ADK either as a bare `claude-*` id (the built-in
+# Anthropic backend, and the Vertex `publishers/anthropic/models/...` path once
+# normalized) or behind a LiteLLM `anthropic/...` prefix, which the generic
+# prefix rule below already covers.
+_ANTHROPIC_MODEL_PATTERN: Final = re.compile(r"^claude[-.]", re.IGNORECASE)
+
+# Leading segments of a resource-path model id, e.g. a Model Garden path like
+# `projects/<p>/locations/<l>/publishers/<pub>/models/<m>` or a tuned-model id
+# like `tunedModels/<id>`. They name a resource collection, never a provider,
+# so the provider-prefix rule must not read one as one.
+_RESOURCE_COLLECTION_SEGMENTS: Final = frozenset({
+    "endpoints",
+    "locations",
+    "models",
+    "projects",
+    "publishers",
+    "tunedmodels",
+})
+
+
+def _resolve_gen_ai_system_name(model: str | None) -> str:
+  """Returns the `gen_ai.system` / `gen_ai.provider.name` value for a model.
+
+  The name has to follow the model actually being served, otherwise every
+  provider is reported as Gemini. A LiteLLM-style `<provider>/<model>` id
+  carries the provider in its prefix, which semantic conventions allow as a
+  lowercased name outside their well-known set. The prefix is read off the bare
+  model name so that a resource path, whose leading segments describe where the
+  model lives rather than who serves it, is not mistaken for one. When no model
+  id is available, or the id names no provider, the deployment-derived
+  Gemini/Vertex name is used, since Gemini is the backend ADK talks to
+  natively.
+
+  Args:
+    model: The model id the request is being served by, if known.
+  """
+  if not model or is_gemini_model(model):
+    return _guess_gemini_system_name()
+
+  model_name = extract_model_name(model)
+  if _ANTHROPIC_MODEL_PATTERN.match(model_name):
+    return GenAiSystemValues.ANTHROPIC.name.lower()
+
+  provider, separator, _ = model_name.partition("/")
+  provider = provider.lower()
+  if separator and provider and provider not in _RESOURCE_COLLECTION_SEGMENTS:
+    return provider
+
+  return _guess_gemini_system_name()
+
+
+def _agent_model_name(agent: BaseAgent | BaseNode) -> str | None:
+  """Returns the model id configured on an agent, if it has one."""
+  from ..agents.llm_agent import LlmAgent
+
+  if not isinstance(agent, LlmAgent):
+    return None
+
+  model = agent.model if agent.model != "" else agent._default_model
+  return model if isinstance(model, str) else model.model
+
+
+def _inference_system_name(
+    invocation_context: InvocationContext | None,
+    llm_response: LlmResponse,
+) -> str:
+  """Returns the system name of the model that produced an inference result."""
+  model = llm_response.model_version
+  if not model and invocation_context is not None:
+    agent = invocation_context.agent
+    if agent is not None:
+      model = _agent_model_name(agent)
+  return _resolve_gen_ai_system_name(model)