Add ToolMetadataExporter

Directory.Packages.props

@@ -59,7 +59,8 @@
     <PackageVersion Include="Azure.ResourceManager.StorageSync" Version="1.3.1" />
     <PackageVersion Include="Azure.ResourceManager.FileShares" Version="1.0.0-beta.1" />
     <PackageVersion Include="Azure.ResourceManager.ResourceGraph" Version="1.1.0" />
-    <PackageVersion Include="Microsoft.Azure.Kusto.Data" Version="13.0.2" />
+    <PackageVersion Include="Microsoft.Azure.Kusto.Data" Version="14.0.1" />
+    <PackageVersion Include="Microsoft.Azure.Kusto.Ingest" Version="14.0.1" />
     <PackageVersion Include="Microsoft.CognitiveServices.Speech" Version="1.46.0" />
     <PackageVersion Include="Microsoft.Identity.Client.Broker" Version="4.72.1" />
     <PackageVersion Include="Microsoft.Extensions.AI.Abstractions" Version="10.2.0" />

eng/tools/ToolDescriptionEvaluator/src/Models/McpModels.cs

@@ -83,6 +83,9 @@ public class ToolAnnotations
 // Tool definition for azmcp tools list response
 public class Tool
 {
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
     [JsonPropertyName("name")]
     public required string Name { get; set; }
 

eng/tools/ToolMetadataExporter/src/AppConfiguration.cs

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace ToolMetadataExporter;
+
+public class AppConfiguration
+{
+    public string? IngestionEndpoint { get; set; }
+
+    public string? QueryEndpoint { get; set; }
+
+    public string? DatabaseName { get; set; }
+
+    public string? McpToolEventsTableName { get; set; }
+
+    public string? QueriesFolder { get; set; } = "Resources/queries";
+
+    public string? WorkDirectory { get; set; }
+
+    public bool IsDryRun { get; set; }
+
+    public string? AzmcpExe { get; set; }
+
+    public bool IsAzmcpExeSpecified { get; set; }
+}

eng/tools/ToolMetadataExporter/src/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("ToolMetadataExporter.UnitTests")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

eng/tools/ToolMetadataExporter/src/GlobalUsings.cs

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+global using System;
+global using System.Text.Json;

eng/tools/ToolMetadataExporter/src/Models/AzureMcpTool.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace ToolMetadataExporter.Models;
+
+public record AzureMcpTool(
+    string ToolId,
+    string ToolName,
+    string ToolArea);

eng/tools/ToolMetadataExporter/src/Models/CommandLineOptions.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace ToolMetadataExporter.Models;
+
+/// <summary>
+/// Options specified via command line arguments. Supported options are:
+/// <list type="bullet">
+///     <item><c>--dry-run</c>: If specified, the tool will run in dry-run mode, meaning no changes will be made to the target datastore.</item>
+///     <item><c>--azmcp-exe &lt;path&gt;</c>: The path to the azmcp executable to use for interacting with the MCP server.</item>
+/// </list>
+/// </summary>
+internal class CommandLineOptions
+{
+    /// <summary>
+    /// Gets or sets a value indicating whether the tool analysis should be performed as a dry run.
+    /// </summary>
+    /// <remarks>When set to <see langword="true"/>, the operation is performed, output to the console, but not persisted to the datastore. When set to
+    /// <see langword="false"/>, the operation is executed normally.</remarks>
+    public bool? IsDryRun { get; set; }
+
+    /// <summary>
+    /// Gets or sets the full path to the AzMcp executable file.
+    /// </summary>
+    public string? AzmcpExe { get; set; }
+}

eng/tools/ToolMetadataExporter/src/Models/Kusto/McpToolEvent.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+using Kusto.Data.Common;
+
+namespace ToolMetadataExporter.Models.Kusto;
+
+public class McpToolEvent
+{
+    private const string EventTimeColumn = "EventTime";
+    private const string EventTypeColumn = "EventType";
+    private const string ServerNameColumn = "ServerName";
+    private const string ServerVersionColumn = "ServerVersion";
+    private const string ToolIdColumn = "ToolId";
+    private const string ToolNameColumn = "ToolName";
+    private const string ToolAreaColumn = "ToolArea";
+    private const string ReplacedByToolNameColumn = "ReplacedByToolName";
+    private const string ReplacedByToolAreaColumn = "ReplacedByToolArea";
+
+    [JsonPropertyName(EventTimeColumn)]
+    public DateTimeOffset? EventTime { get; set; }
+
+    [JsonPropertyName(EventTypeColumn)]
+    public McpToolEventType? EventType { get; set; }
+
+    [JsonPropertyName(ServerNameColumn)]
+    public string? ServerName { get; set; }
+
+    [JsonPropertyName(ServerVersionColumn)]
+    public string? ServerVersion { get; set; }
+
+    [JsonPropertyName(ToolIdColumn)]
+    public string? ToolId { get; set; }
+
+    [JsonPropertyName(ToolNameColumn)]
+    public string? ToolName { get; set; }
+
+    [JsonPropertyName(ToolAreaColumn)]
+    public string? ToolArea { get; set; }
+
+    [JsonPropertyName(ReplacedByToolNameColumn)]
+    public string? ReplacedByToolName { get; set; }
+
+    [JsonPropertyName(ReplacedByToolAreaColumn)]
+    public string? ReplacedByToolArea { get; set; }
+
+    public static ColumnMapping[] GetColumnMappings()
+    {
+        return [
+            new ColumnMapping { ColumnName = EventTimeColumn, ColumnType = "datetime" },
+            new ColumnMapping { ColumnName = EventTypeColumn, ColumnType = "string"},
+            new ColumnMapping { ColumnName = ReplacedByToolAreaColumn, ColumnType = "string"},
+            new ColumnMapping { ColumnName = ReplacedByToolNameColumn, ColumnType = "string"},
+            new ColumnMapping { ColumnName = ServerVersionColumn, ColumnType = "string" },
+            new ColumnMapping { ColumnName = ToolAreaColumn , ColumnType = "string" },
+            new ColumnMapping { ColumnName = ToolIdColumn, ColumnType = "string"},
+            new ColumnMapping { ColumnName = ToolNameColumn, ColumnType = "string" },
+            new ColumnMapping { ColumnName = ServerNameColumn, ColumnType = "string" },
+        ];
+    }
+}

eng/tools/ToolMetadataExporter/src/Models/Kusto/McpToolEventType.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+
+namespace ToolMetadataExporter.Models.Kusto;
+
+public enum McpToolEventType
+{
+    [JsonStringEnumMemberName("Created")]
+    Created,
+    [JsonStringEnumMemberName("Updated")]
+    Updated,
+    [JsonStringEnumMemberName("Deleted")]
+    Deleted
+}

eng/tools/ToolMetadataExporter/src/Models/ModelsSerializationContext.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+using ToolMetadataExporter.Models.Kusto;
+
+namespace ToolMetadataExporter.Models;
+
+[JsonSerializable(typeof(ServerInfo))]
+[JsonSerializable(typeof(ServerInfoResult))]
+[JsonSerializable(typeof(McpToolEvent))]
+[JsonSerializable(typeof(McpToolEventType))]
+[JsonSerializable(typeof(List<McpToolEvent>))]
+[JsonSourceGenerationOptions(Converters = [typeof(JsonStringEnumConverter<McpToolEventType>)])]
+public partial class ModelsSerializationContext : JsonSerializerContext
+{
+}

eng/tools/ToolMetadataExporter/src/Models/ServerInfoResult.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+
+namespace ToolMetadataExporter.Models;
+
+/// <summary>
+/// The result of a `server info` request from the MCP server.
+/// </summary>
+public class ServerInfoResult
+{
+    [JsonPropertyName("status")]
+    public int Status { get; set; }
+
+    [JsonPropertyName("message")]
+    public string? Message { get; set; }
+
+    [JsonPropertyName("results")]
+    public ServerInfo? Results { get; set; }
+}
+
+public class ServerInfo
+{
+    [JsonPropertyName("name")]
+    public string Name { get; set; } = string.Empty;
+
+    [JsonPropertyName("version")]
+    public string Version { get; set; } = string.Empty;
+}

eng/tools/ToolMetadataExporter/src/Program.cs

@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Azure.Core;
+using Azure.Identity;
+using Kusto.Data;
+using Kusto.Data.Common;
+using Kusto.Data.Net.Client;
+using Kusto.Ingest;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using ToolMetadataExporter.Models;
+using ToolMetadataExporter.Services;
+
+namespace ToolMetadataExporter;
+
+public class Program
+{
+    public static async Task Main(string[] args)
+    {
+        var builder = Host.CreateApplicationBuilder(args);
+
+        ConfigureServices(builder.Services, builder.Configuration);
+        ConfigureAzureServices(builder.Services);
+
+        var host = builder.Build();
+        var analyzer = host.Services.GetRequiredService<ToolAnalyzer>();
+
+        await analyzer.RunAsync(DateTimeOffset.UtcNow);
+    }
+
+    private static void ConfigureServices(IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddLogging(builder =>
+        {
+            builder.AddConsole();
+        });
+
+        services.AddSingleton<IAzureMcpDatastore, AzureMcpKustoDatastore>()
+            .AddSingleton<Utility>()
+            .AddSingleton<AzmcpProgram>()
+            .AddSingleton<ToolAnalyzer>();
+
+        services.AddOptions<CommandLineOptions>()
+            .Bind(configuration);
+
+        services.AddOptions<AppConfiguration>()
+            .Bind<AppConfiguration>(configuration.GetSection("AppConfig"))
+            .Configure<IOptions<CommandLineOptions>>((existing, commandLineOptions) =>
+            {
+                // Command-line IsDryRun overrides appsettings.json file value.
+                if (commandLineOptions.Value.IsDryRun.HasValue)
+                {
+                    existing.IsDryRun = commandLineOptions.Value.IsDryRun.Value;
+                }
+
+                var exeDir = AppContext.BaseDirectory;
+
+                // If a path to azmcp.exe is not provided. Assume that this is running within the context of
+                // the repository and try to find it.
+                existing.IsAzmcpExeSpecified = !string.IsNullOrEmpty(commandLineOptions.Value.AzmcpExe);
+                if (existing.IsAzmcpExeSpecified)
+                {
+                    existing.AzmcpExe = commandLineOptions.Value.AzmcpExe!;
+
+                    if (existing.WorkDirectory == null)
+                    {
+                        existing.WorkDirectory = exeDir;
+                    }
+                }
+                else
+                {
+                    var repoRoot = Utility.FindRepoRoot(exeDir);
+                    if (existing.WorkDirectory == null)
+                    {
+                        existing.WorkDirectory = Path.Combine(repoRoot, ".work");
+                    }
+
+                    existing.AzmcpExe = Path.Combine(repoRoot, "eng", "tools", "Azmcp", "azmcp.exe");
+                }
+            });
+    }
+
+    private static void ConfigureAzureServices(IServiceCollection services)
+    {
+        services.AddScoped<TokenCredential>(sp =>
+        {
+            var credential = new ChainedTokenCredential(
+                new ManagedIdentityCredential(),
+                new DefaultAzureCredential()
+            );
+
+            return credential;
+        });
+        services.AddSingleton<ICslQueryProvider>(sp =>
+        {
+            var config = sp.GetRequiredService<IOptions<AppConfiguration>>();
+
+            var connectionStringBuilder = new KustoConnectionStringBuilder(config.Value.QueryEndpoint)
+                .WithAadUserPromptAuthentication()
+                .WithAadAzCliAuthentication(interactive: true);
+
+            return KustoClientFactory.CreateCslQueryProvider(connectionStringBuilder);
+        });
+        services.AddSingleton<IKustoIngestClient>(sp =>
+        {
+            var config = sp.GetRequiredService<IOptions<AppConfiguration>>();
+
+            var connectionStringBuilder = new KustoConnectionStringBuilder(config.Value.IngestionEndpoint)
+                .WithAadUserPromptAuthentication()
+                .WithAadAzCliAuthentication(interactive: true);
+
+            return KustoIngestFactory.CreateDirectIngestClient(connectionStringBuilder);
+        });
+    }
+}

eng/tools/ToolMetadataExporter/src/Properties/launchSettings.json

@@ -0,0 +1,10 @@
+{
+  "profiles": {
+    "ToolMetadataExporter": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

eng/tools/ToolMetadataExporter/src/README.md

@@ -0,0 +1,36 @@
+# Tool Metadata Exporter
+
+
+## Development Setup
+
+### 1. Create Datastore
+
+1. Create an Azure Data Explorer Cluster (e.g. "mcp-test-instance")
+1. Create a database (e.g. "McpToolMetadata") within the cluster
+1. In https://dataexplorer.azure.com/, connect to cluster
+1. Click on "Query" tab
+1. Execute [`CreateTable.kql`](./Resources/queries/CreateTable.kql) against the cluster and database
+
+### 2. Configure Application
+
+1. Open [`appsettings.Development.json`](./appsettings.Development.json)
+1. Update "IngestionEndpoint", "QueryEndpoint", "DatabaseName" with the appropriate cluster and database names.  Using the example from previous step, it would look like this:
+   ```json
+     "AppConfig": {
+        "IngestionEndpoint": "https://ingest-mcp-test-instance.westus2.kusto.windows.net",
+        "QueryEndpoint": "https://mcp-test-instance.westus2.kusto.windows.net",
+        "DatabaseName": "McpToolMetadata"
+    }
+   ```
+   To find values for "QueryEndpoint" and "IngestionEndpoint", navigate to the Azure Data Explorer Cluster in the Azure portal, and in the "Essentials" panel window, look for.
+    1. "IngestionEndpoint" is "Data Ingestion URI"
+    1. "QueryEndpoint" is "URI"
+
+### 3. Run Application
+
+1. Open a terminal in the project src directory: [$RepositoryRoot/eng/tools/ToolMetadataExporter/src](./)
+1. Run the application using the command:
+   ```bash
+   dotnet run --environment DOTNET_ENVIRONMENT=Development
+   ```
+   The environment variable `DOTNET_ENVIRONMENT` is set to `Development` to ensure the application uses [`appsettings.Development.json`](./appsettings.Development.json)