Metrics Server Example

using Mcp.Gateway.Tools;
using Mcp.Gateway.Tools.Lifecycle;

var builder = WebApplication.CreateBuilder(args);

// Register MCP Gateway
builder.AddToolsService();

// Add lifecycle hooks (v1.8.0)
builder.AddToolLifecycleHook<LoggingToolLifecycleHook>();
builder.AddToolLifecycleHook<MetricsToolLifecycleHook>();

var app = builder.Build();

// stdio mode
if (args.Contains("--stdio"))
{
    await ToolInvoker.RunStdioModeAsync(app.Services);
    return;
}

// HTTP mode
app.UseWebSockets();
app.UseProtocolVersionValidation();
app.MapStreamableHttpEndpoint("/mcp");

// Metrics endpoint (v1.8.0)
app.MapGet("/metrics", (IEnumerable<IToolLifecycleHook> hooks) =>
{
    var metricsHook = hooks.OfType<MetricsToolLifecycleHook>().FirstOrDefault();
    
    if (metricsHook == null)
    {
        return Results.Json(new
        {
            error = "MetricsToolLifecycleHook not registered"
        });
    }
    
    var allMetrics = metricsHook.GetMetrics();
    
    return Results.Json(new
    {
        timestamp = DateTime.UtcNow,
        totalTools = allMetrics.Count,
        metrics = allMetrics.Select(kvp => new
        {
            tool = kvp.Key,
            invocations = kvp.Value.InvocationCount,
            successes = kvp.Value.SuccessCount,
            failures = kvp.Value.FailureCount,
            successRate = Math.Round(kvp.Value.SuccessRate * 100, 2),
            avgDuration = Math.Round(kvp.Value.AverageDuration.TotalMilliseconds, 2),
            minDuration = Math.Round(kvp.Value.MinDuration.TotalMilliseconds, 2),
            maxDuration = Math.Round(kvp.Value.MaxDuration.TotalMilliseconds, 2),
            errors = kvp.Value.ErrorCounts.ToDictionary(e => e.Key, e => e.Value)
        })
    });
});

app.Run();

using Mcp.Gateway.Tools;

namespace MetricsMcpServer.Tools;

public class CalculatorTools
{
    [McpTool("add_numbers", Description = "Adds two numbers")]
    public JsonRpcMessage AddNumbers(TypedJsonRpc<AddParams> request)
    {
        var args = request.GetParams()
            ?? throw new ToolInvalidParamsException("Parameters required");

        var result = args.A + args.B;
        
        return ToolResponse.Success(request.Id, new { result });
    }

    [McpTool("divide", Description = "Divides two numbers")]
    public JsonRpcMessage Divide(TypedJsonRpc<DivideParams> request)
    {
        var args = request.GetParams()
            ?? throw new ToolInvalidParamsException("Parameters required");

        if (args.Divisor == 0)
        {
            throw new ToolInvalidParamsException("Cannot divide by zero");
        }

        var result = args.Dividend / args.Divisor;
        
        return ToolResponse.Success(request.Id, new { result });
    }

    [McpTool("slow_operation", Description = "Simulates a slow operation")]
    public async Task<JsonRpcMessage> SlowOperation(JsonRpcMessage request)
    {
        // Simulate slow operation
        await Task.Delay(TimeSpan.FromMilliseconds(100));
        
        return ToolResponse.Success(request.Id, 
            new { message = "Operation completed" });
    }
}

public record AddParams(double A, double B);
public record DivideParams(double Dividend, double Divisor);

builder.AddToolLifecycleHook<LoggingToolLifecycleHook>();  // Logs to ILogger
builder.AddToolLifecycleHook<MetricsToolLifecycleHook>();  // Collects metrics

app.MapGet("/metrics", (IEnumerable<IToolLifecycleHook> hooks) =>
{
    var metricsHook = hooks.OfType<MetricsToolLifecycleHook>().FirstOrDefault();
    var metrics = metricsHook?.GetMetrics();
    return Results.Json(metrics);
});

using Prometheus;

// Create Prometheus metrics
var invocations = Metrics.CreateCounter(
    "mcp_tool_invocations_total",
    "Total tool invocations",
    new CounterConfiguration { LabelNames = new[] { "tool" } });

// Create custom hook
public class PrometheusHook : IToolLifecycleHook
{
    public Task OnToolInvokingAsync(string toolName, JsonRpcMessage request)
    {
        invocations.WithLabels(toolName).Inc();
        return Task.CompletedTask;
    }
    
    // ... other methods
}

// Register hook
builder.AddToolLifecycleHook<PrometheusHook>();

// Expose Prometheus endpoint
app.MapMetrics();  // /metrics in Prometheus format

using Microsoft.ApplicationInsights;

public class ApplicationInsightsHook : IToolLifecycleHook
{
    private readonly TelemetryClient _telemetry;
    
    public ApplicationInsightsHook(TelemetryClient telemetry)
    {
        _telemetry = telemetry;
    }
    
    public Task OnToolCompletedAsync(
        string toolName,
        JsonRpcMessage response,
        TimeSpan duration)
    {
        var metric = new MetricTelemetry(
            "ToolDuration",
            duration.TotalMilliseconds);
        
        metric.Properties["tool"] = toolName;
        metric.Properties["status"] = "success";
        
        _telemetry.TrackMetric(metric);
        
        return Task.CompletedTask;
    }
    
    // ... other methods
}

// Register
builder.Services.AddApplicationInsightsTelemetry();
builder.AddToolLifecycleHook<ApplicationInsightsHook>();

public class DatabaseMetricsHook : IToolLifecycleHook
{
    private readonly IMetricsRepository _repository;
    
    public async Task OnToolCompletedAsync(
        string toolName,
        JsonRpcMessage response,
        TimeSpan duration)
    {
        await _repository.SaveMetricAsync(new ToolMetric
        {
            ToolName = toolName,
            Status = "success",
            Duration = duration,
            Timestamp = DateTime.UtcNow
        });
    }
    
    // ... other methods
}

using Xunit;

public class MetricsTests
{
    [Fact]
    public async Task Metrics_AfterToolInvocation_TracksInvocationCount()
    {
        // Arrange
        using var server = new McpGatewayFixture();
        var client = server.CreateClient();
        
        // Act - Call tool 3 times
        for (int i = 0; i < 3; i++)
        {
            await client.PostAsJsonAsync("/mcp", new
            {
                jsonrpc = "2.0",
                method = "tools/call",
                @params = new
                {
                    name = "add_numbers",
                    arguments = new { A = 5, B = 3 }
                },
                id = i
            });
        }
        
        // Get metrics
        var response = await client.GetAsync("/metrics");
        var metrics = await response.Content.ReadFromJsonAsync<MetricsResponse>();
        
        // Assert
        var toolMetrics = metrics.Metrics.FirstOrDefault(m => m.Tool == "add_numbers");
        Assert.NotNull(toolMetrics);
        Assert.Equal(3, toolMetrics.Invocations);
        Assert.Equal(3, toolMetrics.Successes);
        Assert.Equal(0, toolMetrics.Failures);
        Assert.Equal(100.0, toolMetrics.SuccessRate);
    }
}