Add centralized OpenTelemetry tracing for MCP tool execution

src/Azure.DataApiBuilder.Mcp/Azure.DataApiBuilder.Mcp.csproj

@@ -6,6 +6,10 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="Azure.DataApiBuilder.Service.Tests" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="ModelContextProtocol" />
     <PackageReference Include="ModelContextProtocol.AspNetCore" />

src/Azure.DataApiBuilder.Mcp/Core/DynamicCustomTool.cs

@@ -38,7 +38,6 @@ namespace Azure.DataApiBuilder.Mcp.Core
     /// </summary>
     public class DynamicCustomTool : IMcpTool
     {
-        private readonly string _entityName;
         private readonly Entity _entity;
 
         /// <summary>
@@ -48,7 +47,7 @@ public class DynamicCustomTool : IMcpTool
         /// <param name="entity">The entity configuration object.</param>
         public DynamicCustomTool(string entityName, Entity entity)
         {
-            _entityName = entityName ?? throw new ArgumentNullException(nameof(entityName));
+            EntityName = entityName ?? throw new ArgumentNullException(nameof(entityName));
             _entity = entity ?? throw new ArgumentNullException(nameof(entity));
 
             // Validate that this is a stored procedure
@@ -65,12 +64,17 @@ public DynamicCustomTool(string entityName, Entity entity)
         /// </summary>
         public ToolType ToolType { get; } = ToolType.Custom;
 
+        /// <summary>
+        /// Gets the entity name associated with this custom tool.
+        /// </summary>
+        public string EntityName { get; }
+
         /// <summary>
         /// Gets the metadata for this custom tool, including name, description, and input schema.
         /// </summary>
         public Tool GetToolMetadata()
         {
-            string toolName = ConvertToToolName(_entityName);
+            string toolName = ConvertToToolName(EntityName);
             string description = _entity.Description ?? $"Executes the {toolName} stored procedure";
 
             // Build input schema based on parameters
@@ -114,25 +118,25 @@ public async Task<CallToolResult> ExecuteAsync(
                 }
 
                 // 3) Validate entity still exists in configuration
-                if (!config.Entities.TryGetValue(_entityName, out Entity? entityConfig))
+                if (!config.Entities.TryGetValue(EntityName, out Entity? entityConfig))
                 {
-                    return McpResponseBuilder.BuildErrorResult(toolName, "EntityNotFound", $"Entity '{_entityName}' not found in configuration.", logger);
+                    return McpResponseBuilder.BuildErrorResult(toolName, "EntityNotFound", $"Entity '{EntityName}' not found in configuration.", logger);
                 }
 
                 if (entityConfig.Source.Type != EntitySourceType.StoredProcedure)
                 {
-                    return McpResponseBuilder.BuildErrorResult(toolName, "InvalidEntity", $"Entity {_entityName} is not a stored procedure.", logger);
+                    return McpResponseBuilder.BuildErrorResult(toolName, "InvalidEntity", $"Entity {EntityName} is not a stored procedure.", logger);
                 }
 
                 // Check if custom tool is still enabled for this entity
                 if (entityConfig.Mcp?.CustomToolEnabled != true)
                 {
-                    return McpErrorHelpers.ToolDisabled(toolName, logger, $"Custom tool is disabled for entity '{_entityName}'.");
+                    return McpErrorHelpers.ToolDisabled(toolName, logger, $"Custom tool is disabled for entity '{EntityName}'.");
                 }
 
                 // 4) Resolve metadata
                 if (!McpMetadataHelper.TryResolveMetadata(
-                        _entityName,
+                        EntityName,
                         config,
                         serviceProvider,
                         out ISqlMetadataProvider sqlMetadataProvider,
@@ -150,18 +154,18 @@ public async Task<CallToolResult> ExecuteAsync(
 
                 if (!McpAuthorizationHelper.ValidateRoleContext(httpContext, authResolver, out string roleError))
                 {
-                    return McpErrorHelpers.PermissionDenied(toolName, _entityName, "execute", roleError, logger);
+                    return McpErrorHelpers.PermissionDenied(toolName, EntityName, "execute", roleError, logger);
                 }
 
                 if (!McpAuthorizationHelper.TryResolveAuthorizedRole(
                     httpContext!,
                     authResolver,
-                    _entityName,
+                    EntityName,
                     EntityActionOperation.Execute,
                     out string? effectiveRole,
                     out string authError))
                 {
-                    return McpErrorHelpers.PermissionDenied(toolName, _entityName, "execute", authError, logger);
+                    return McpErrorHelpers.PermissionDenied(toolName, EntityName, "execute", authError, logger);
                 }
 
                 // 6) Build request payload
@@ -175,7 +179,7 @@ public async Task<CallToolResult> ExecuteAsync(
 
                 // 7) Build stored procedure execution context
                 StoredProcedureRequestContext context = new(
-                    entityName: _entityName,
+                    entityName: EntityName,
                     dbo: dbObject,
                     requestPayloadRoot: requestPayloadRoot,
                     operationType: EntityActionOperation.Execute);
@@ -218,7 +222,7 @@ public async Task<CallToolResult> ExecuteAsync(
                 }
                 catch (DataApiBuilderException dabEx)
                 {
-                    logger?.LogError(dabEx, "Error executing custom tool {ToolName} for entity {Entity}", toolName, _entityName);
+                    logger?.LogError(dabEx, "Error executing custom tool {ToolName} for entity {Entity}", toolName, EntityName);
                     return McpResponseBuilder.BuildErrorResult(toolName, "ExecutionError", dabEx.Message, logger);
                 }
                 catch (SqlException sqlEx)
@@ -238,15 +242,15 @@ public async Task<CallToolResult> ExecuteAsync(
                 }
 
                 // 9) Build success response
-                return BuildExecuteSuccessResponse(toolName, _entityName, parameters, queryResult, logger);
+                return BuildExecuteSuccessResponse(toolName, EntityName, parameters, queryResult, logger);
             }
             catch (OperationCanceledException)
             {
                 return McpResponseBuilder.BuildErrorResult(toolName, "OperationCanceled", "The operation was canceled.", logger);
             }
             catch (Exception ex)
             {
-                logger?.LogError(ex, "Unexpected error in DynamicCustomTool for {EntityName}", _entityName);
+                logger?.LogError(ex, "Unexpected error in DynamicCustomTool for {EntityName}", EntityName);
                 return McpResponseBuilder.BuildErrorResult(toolName, "UnexpectedError", "An unexpected error occurred.", logger);
             }
         }

src/Azure.DataApiBuilder.Mcp/Core/McpServerConfiguration.cs

@@ -3,6 +3,7 @@
 
 using System.Text.Json;
 using Azure.DataApiBuilder.Mcp.Model;
+using Azure.DataApiBuilder.Mcp.Utils;
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol;
 using ModelContextProtocol.Protocol;
@@ -61,22 +62,23 @@ internal static IServiceCollection ConfigureMcpServer(this IServiceCollection se
                             }
 
                             JsonDocument? arguments = null;
-                            if (request.Params?.Arguments != null)
+                            try
                             {
-                                // Convert IReadOnlyDictionary<string, JsonElement> to JsonDocument
-                                Dictionary<string, object?> jsonObject = new();
-                                foreach (KeyValuePair<string, JsonElement> kvp in request.Params.Arguments)
+                                if (request.Params?.Arguments != null)
                                 {
-                                    jsonObject[kvp.Key] = kvp.Value;
-                                }
+                                    // Convert IReadOnlyDictionary<string, JsonElement> to JsonDocument
+                                    Dictionary<string, object?> jsonObject = new();
+                                    foreach (KeyValuePair<string, JsonElement> kvp in request.Params.Arguments)
+                                    {
+                                        jsonObject[kvp.Key] = kvp.Value;
+                                    }
 
-                                string json = JsonSerializer.Serialize(jsonObject);
-                                arguments = JsonDocument.Parse(json);
-                            }
+                                    string json = JsonSerializer.Serialize(jsonObject);
+                                    arguments = JsonDocument.Parse(json);
+                                }
 
-                            try
-                            {
-                                return await tool!.ExecuteAsync(arguments, request.Services!, ct);
+                                return await McpTelemetryHelper.ExecuteWithTelemetryAsync(
+                                    tool!, toolName, arguments, request.Services!, ct);
                             }
                             finally
                             {

src/Azure.DataApiBuilder.Mcp/Core/McpStdioServer.cs

@@ -7,6 +7,7 @@
 using Azure.DataApiBuilder.Core.AuthenticationHelpers.AuthenticationSimulator;
 using Azure.DataApiBuilder.Core.Configurations;
 using Azure.DataApiBuilder.Mcp.Model;
+using Azure.DataApiBuilder.Mcp.Utils;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -284,7 +285,7 @@ private async Task HandleCallToolAsync(JsonElement? id, JsonElement root, Cancel
                     Console.Error.WriteLine($"[MCP DEBUG] callTool → tool: {toolName}, args: <none>");
                 }
 
-                // Execute the tool.
+                // Execute the tool with telemetry.
                 // If a MCP stdio role override is set in the environment, create
                 // a request HttpContext with the X-MS-API-ROLE header so tools and authorization
                 // helpers that read IHttpContextAccessor will see the role. We also ensure the
@@ -319,7 +320,8 @@ private async Task HandleCallToolAsync(JsonElement? id, JsonElement root, Cancel
                     try
                     {
                         // Execute the tool with the scoped service provider so any scoped services resolve correctly.
-                        callResult = await tool.ExecuteAsync(argsDoc, scopedProvider, ct);
+                        callResult = await McpTelemetryHelper.ExecuteWithTelemetryAsync(
+                            tool, toolName!, argsDoc, scopedProvider, ct);
                     }
                     finally
                     {
@@ -332,7 +334,8 @@ private async Task HandleCallToolAsync(JsonElement? id, JsonElement root, Cancel
                 }
                 else
                 {
-                    callResult = await tool.ExecuteAsync(argsDoc, _serviceProvider, ct);
+                    callResult = await McpTelemetryHelper.ExecuteWithTelemetryAsync(
+                        tool, toolName!, argsDoc, _serviceProvider, ct);
                 }
 
                 // Normalize to MCP content blocks (array). We try to pass through if a 'Content' property exists,

src/Azure.DataApiBuilder.Mcp/Utils/McpTelemetryErrorCodes.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Mcp.Utils
+{
+    /// <summary>
+    /// Constants for MCP telemetry error codes.
+    /// </summary>
+    internal static class McpTelemetryErrorCodes
+    {
+        /// <summary>
+        /// Generic execution failure error code.
+        /// </summary>
+        public const string EXECUTION_FAILED = "ExecutionFailed";
+
+        /// <summary>
+        /// Authentication failure error code.
+        /// </summary>
+        public const string AUTHENTICATION_FAILED = "AuthenticationFailed";
+
+        /// <summary>
+        /// Authorization failure error code.
+        /// </summary>
+        public const string AUTHORIZATION_FAILED = "AuthorizationFailed";
+
+        /// <summary>
+        /// Database operation failure error code.
+        /// </summary>
+        public const string DATABASE_ERROR = "DatabaseError";
+
+        /// <summary>
+        /// Invalid request or arguments error code.
+        /// </summary>
+        public const string INVALID_REQUEST = "InvalidRequest";
+
+        /// <summary>
+        /// Operation cancelled error code.
+        /// </summary>
+        public const string OPERATION_CANCELLED = "OperationCancelled";
+    }
+}