Python: Update kernel function span (#12285)

### Motivation and Context

<!-- Thank you for your contribution to the semantic-kernel repo!
Please help reviewers and future users, providing the following
information:
  1. Why is this change required?
  2. What problem does it solve?
  3. What scenario does it contribute to?
  4. If it fixes an open issue, please link to the issue here.
-->
Closing #12262

### Description

<!-- Describe your changes, the overall approach, the underlying design.
These notes will help understanding how your code works. Thanks! -->
This PR updates tracing support for function execution across both .NET
and Python according to the latest OTel GenAI semantic conventions:
https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#execute-tool-span

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [x] The code builds clean without any errors or warnings
- [x] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [x] All unit tests pass, and I have added new tests where possible
- [ ] I didn't break anyone 😄

Author: TaoChenOSU

dotnet/src/InternalUtilities/src/Diagnostics/ActivityExtensions.cs

@@ -13,6 +13,20 @@ namespace Microsoft.SemanticKernel.Diagnostics;
 [ExcludeFromCodeCoverage]
 internal static class ActivityExtensions
 {
+    /// <summary>
+    /// Starts an activity with the appropriate tags for a kernel function execution.
+    /// </summary>
+    public static Activity? StartFunctionActivity(this ActivitySource source, string functionName, string functionDescription)
+    {
+        const string OperationName = "execute_tool";
+
+        return source.StartActivityWithTags($"{OperationName} {functionName}", [
+            new KeyValuePair<string, object?>("gen_ai.operation.name", OperationName),
+            new KeyValuePair<string, object?>("gen_ai.tool.name", functionName),
+            new KeyValuePair<string, object?>("gen_ai.tool.description", functionDescription)
+        ], ActivityKind.Internal);
+    }
+
     /// <summary>
     /// Starts an activity with the specified name and tags.
     /// </summary>

dotnet/src/SemanticKernel.Abstractions/Functions/KernelFunction.cs

@@ -239,7 +239,7 @@ public async Task<FunctionResult> InvokeAsync(
         kernel ??= this.Kernel;
         Verify.NotNull(kernel);
 
-        using var activity = s_activitySource.StartActivity(this.Name);
+        using var activity = s_activitySource.StartFunctionActivity(this.Name, this.Description);
         ILogger logger = kernel.LoggerFactory.CreateLogger(typeof(KernelFunction)) ?? NullLogger.Instance;
 
         // Ensure arguments are initialized.
@@ -342,7 +342,7 @@ public async IAsyncEnumerable<TResult> InvokeStreamingAsync<TResult>(
         kernel ??= this.Kernel;
         Verify.NotNull(kernel);
 
-        using var activity = s_activitySource.StartActivity(this.Name);
+        using var activity = s_activitySource.StartFunctionActivity(this.Name, this.Description);
         ILogger logger = kernel.LoggerFactory.CreateLogger(this.Name) ?? NullLogger.Instance;
 
         arguments ??= [];

python/semantic_kernel/filters/auto_function_invocation/auto_function_invocation_context.py

@@ -7,6 +7,7 @@
 if TYPE_CHECKING:
     from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
     from semantic_kernel.contents.chat_history import ChatHistory
+    from semantic_kernel.contents.function_call_content import FunctionCallContent
     from semantic_kernel.functions.function_result import FunctionResult
 
 
@@ -26,6 +27,7 @@ class AutoFunctionInvocationContext(FilterContextBase):
         arguments: The arguments used to call the function.
         is_streaming: Whether the function is streaming.
         chat_history: The chat history or None.
+        function_call_content: The function call content or None.
         function_result: The function result or None.
         request_sequence_index: The request sequence index.
         function_sequence_index: The function sequence index.
@@ -35,6 +37,7 @@ class AutoFunctionInvocationContext(FilterContextBase):
     """
 
     chat_history: "ChatHistory | None" = None
+    function_call_content: "FunctionCallContent | None" = None
     function_result: "FunctionResult | None" = None
     execution_settings: "PromptExecutionSettings | None" = None
     request_sequence_index: int = 0

python/semantic_kernel/filters/kernel_filters_extension.py

@@ -120,6 +120,7 @@ def construct_call_stack(
 
 def _rebuild_auto_function_invocation_context() -> None:
     from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings  # noqa: F401
+    from semantic_kernel.contents import FunctionCallContent  # noqa: F401
     from semantic_kernel.contents.chat_history import ChatHistory  # noqa: F401
     from semantic_kernel.filters.auto_function_invocation.auto_function_invocation_context import (
         AutoFunctionInvocationContext,

python/semantic_kernel/functions/kernel_function.py

@@ -31,6 +31,7 @@
 from semantic_kernel.prompt_template.jinja2_prompt_template import Jinja2PromptTemplate
 from semantic_kernel.prompt_template.kernel_prompt_template import KernelPromptTemplate
 from semantic_kernel.prompt_template.prompt_template_base import PromptTemplateBase
+from semantic_kernel.utils.telemetry.model_diagnostics import function_tracer
 
 if TYPE_CHECKING:
     from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
@@ -236,7 +237,7 @@ async def invoke(
         _rebuild_function_invocation_context()
         function_context = FunctionInvocationContext(function=self, kernel=kernel, arguments=arguments)
 
-        with tracer.start_as_current_span(self.fully_qualified_name) as current_span:
+        with function_tracer.start_as_current_span(tracer, self, metadata) as current_span:
             KernelFunctionLogMessages.log_function_invoking(logger, self.fully_qualified_name)
             KernelFunctionLogMessages.log_function_arguments(logger, arguments)
 
@@ -298,7 +299,7 @@ async def invoke_stream(
             function=self, kernel=kernel, arguments=arguments, is_streaming=True
         )
 
-        with tracer.start_as_current_span(self.fully_qualified_name) as current_span:
+        with function_tracer.start_as_current_span(tracer, self, metadata) as current_span:
             KernelFunctionLogMessages.log_function_streaming_invoking(logger, self.fully_qualified_name)
             KernelFunctionLogMessages.log_function_arguments(logger, arguments)
 

python/semantic_kernel/kernel.py

@@ -418,6 +418,7 @@ async def invoke_function_call(
             arguments=args_cloned,
             is_streaming=is_streaming,
             chat_history=chat_history,
+            function_call_content=function_call,
             execution_settings=execution_settings,
             function_result=FunctionResult(function=function_to_call.metadata, value=None),
             function_count=function_call_count or 0,
@@ -450,7 +451,13 @@ async def invoke_function_call(
     async def _inner_auto_function_invoke_handler(self, context: AutoFunctionInvocationContext):
         """Inner auto function invocation handler."""
         try:
-            result = await context.function.invoke(context.kernel, context.arguments)
+            result = await context.function.invoke(
+                context.kernel,
+                context.arguments,
+                metadata=context.function_call_content.metadata | context.function_call_content.to_dict()
+                if context.function_call_content
+                else {},
+            )
             if result:
                 context.function_result = result
         except Exception as exc:

python/semantic_kernel/utils/telemetry/model_diagnostics/function_tracer.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import TYPE_CHECKING, Any
+
+from opentelemetry import trace
+
+from semantic_kernel.utils.telemetry.model_diagnostics.gen_ai_attributes import (
+    OPERATION,
+    TOOL_CALL_ID,
+    TOOL_DESCRIPTION,
+    TOOL_NAME,
+)
+
+if TYPE_CHECKING:
+    from semantic_kernel.functions.kernel_function import KernelFunction
+
+
+# The operation name is defined by OTeL GenAI semantic conventions:
+# https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#execute-tool-span
+OPERATION_NAME = "execute_tool"
+
+
+def start_as_current_span(
+    tracer: trace.Tracer,
+    function: "KernelFunction",
+    metadata: dict[str, Any] | None = None,
+):
+    """Starts a span for the given function using the provided tracer.
+
+    Args:
+        tracer (trace.Tracer): The OpenTelemetry tracer to use.
+        function (KernelFunction): The function for which to start the span.
+        metadata (dict[str, Any] | None): Optional metadata to include in the span attributes.
+
+    Returns:
+        trace.Span: The started span as a context manager.
+    """
+    attributes = {
+        OPERATION: OPERATION_NAME,
+        TOOL_NAME: function.fully_qualified_name,
+    }
+
+    tool_call_id = metadata.get("id", None) if metadata else None
+    if tool_call_id:
+        attributes[TOOL_CALL_ID] = tool_call_id
+    if function.description:
+        attributes[TOOL_DESCRIPTION] = function.description
+
+    return tracer.start_as_current_span(f"{OPERATION_NAME} {function.fully_qualified_name}", attributes=attributes)

python/semantic_kernel/utils/telemetry/model_diagnostics/gen_ai_attributes.py

@@ -25,6 +25,9 @@
 RESPONSE_ID = "gen_ai.response.id"
 INPUT_TOKENS = "gen_ai.usage.input_tokens"
 OUTPUT_TOKENS = "gen_ai.usage.output_tokens"
+TOOL_CALL_ID = "gen_ai.tool.call.id"
+TOOL_DESCRIPTION = "gen_ai.tool.description"
+TOOL_NAME = "gen_ai.tool.name"
 ADDRESS = "server.address"
 
 # Activity events