How to add logging and monitoring to an MCP server

1npm install pino pino-pretty
2
3// src/logger.ts
4import pino from "pino";
5
6export const logger = pino({
7  level: process.env.LOG_LEVEL || "info",
8  transport: process.env.NODE_ENV === "development" ? {
9    target: "pino-pretty",
10    options: { destination: 2 },  // 2 = stderr file descriptor
11  } : undefined,
12}, pino.destination(2));  // Always write to stderr (fd 2)
13
14// Usage:
15// logger.info({ tool: "read_file", path: "/src" }, "Tool called");
16// logger.error({ err: error, tool: "write_file" }, "Tool failed");

1// src/tool-logger.ts
2import { logger } from "./logger.js";
3import { randomUUID } from "crypto";
4
5export function withLogging<T>(
6  toolName: string,
7  handler: (params: T) => Promise<any>
8): (params: T) => Promise<any> {
9  return async (params: T) => {
10    const requestId = randomUUID().slice(0, 8);
11    const start = performance.now();
12
13    logger.info({
14      requestId,
15      tool: toolName,
16      params: redactSensitive(params as Record<string, unknown>),
17    }, `Tool call started: ${toolName}`);
18
19    try {
20      const result = await handler(params);
21      const durationMs = Math.round(performance.now() - start);
22
23      logger.info({
24        requestId,
25        tool: toolName,
26        durationMs,
27        isError: result.isError || false,
28      }, `Tool call completed: ${toolName} (${durationMs}ms)`);
29
30      return result;
31    } catch (error) {
32      const durationMs = Math.round(performance.now() - start);
33
34      logger.error({
35        requestId,
36        tool: toolName,
37        durationMs,
38        err: error instanceof Error ? { message: error.message, stack: error.stack } : String(error),
39      }, `Tool call failed: ${toolName}`);
40
41      return {
42        content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
43        isError: true,
44      };
45    }
46  };
47}
48
49function redactSensitive(params: Record<string, unknown>): Record<string, unknown> {
50  const redacted = { ...params };
51  for (const key of ["password", "token", "apiKey", "secret"]) {
52    if (key in redacted) redacted[key] = "[REDACTED]";
53  }
54  return redacted;
55}

1npm install @sentry/node
2
3// src/monitoring.ts
4import * as Sentry from "@sentry/node";
5
6export function initMonitoring(): void {
7  if (process.env.SENTRY_DSN) {
8    Sentry.init({
9      dsn: process.env.SENTRY_DSN,
10      environment: process.env.NODE_ENV || "development",
11      tracesSampleRate: 0.1,  // Sample 10% of transactions
12    });
13    console.error("[monitoring] Sentry initialized");
14  }
15}
16
17export function captureToolError(
18  toolName: string,
19  error: Error,
20  params: Record<string, unknown>
21): void {
22  Sentry.withScope((scope) => {
23    scope.setTag("mcp.tool", toolName);
24    scope.setContext("tool_params", params);
25    Sentry.captureException(error);
26  });
27}

1// src/metrics.ts
2import { logger } from "./logger.js";
3
4interface ToolMetrics {
5  calls: number;
6  errors: number;
7  totalMs: number;
8  maxMs: number;
9  lastCallAt: number;
10}
11
12const metrics = new Map<string, ToolMetrics>();
13
14export function recordToolCall(toolName: string, durationMs: number, isError: boolean): void {
15  let m = metrics.get(toolName);
16  if (!m) {
17    m = { calls: 0, errors: 0, totalMs: 0, maxMs: 0, lastCallAt: 0 };
18    metrics.set(toolName, m);
19  }
20  m.calls++;
21  if (isError) m.errors++;
22  m.totalMs += durationMs;
23  m.maxMs = Math.max(m.maxMs, durationMs);
24  m.lastCallAt = Date.now();
25
26  // Alert on high error rate
27  if (m.calls > 10 && m.errors / m.calls > 0.5) {
28    logger.warn({ tool: toolName, errorRate: (m.errors / m.calls).toFixed(2) },
29      `High error rate detected for ${toolName}`);
30  }
31}
32
33export function getMetricsSummary(): Record<string, any> {
34  const summary: Record<string, any> = {};
35  for (const [tool, m] of metrics) {
36    summary[tool] = {
37      totalCalls: m.calls,
38      errorCount: m.errors,
39      errorRate: m.calls > 0 ? (m.errors / m.calls * 100).toFixed(1) + "%" : "0%",
40      avgMs: m.calls > 0 ? Math.round(m.totalMs / m.calls) : 0,
41      maxMs: m.maxMs,
42      lastCallAt: new Date(m.lastCallAt).toISOString(),
43    };
44  }
45  return summary;
46}

1// src/index.ts
2import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
3import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
4import { z } from "zod";
5import { logger } from "./logger.js";
6import { withLogging } from "./tool-logger.js";
7import { initMonitoring } from "./monitoring.js";
8import { getMetricsSummary } from "./metrics.js";
9
10initMonitoring();
11
12const server = new McpServer({ name: "monitored-server", version: "1.0.0" });
13
14server.tool(
15  "read_file",
16  "Read a file's contents",
17  { filePath: z.string() },
18  withLogging("read_file", async ({ filePath }) => {
19    const fs = await import("fs/promises");
20    const content = await fs.readFile(filePath, "utf-8");
21    return { content: [{ type: "text", text: content }] };
22  })
23);
24
25server.tool(
26  "get_server_metrics",
27  "Get server performance metrics for all tools",
28  {},
29  async () => {
30    const summary = getMetricsSummary();
31    return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
32  }
33);
34
35async function main() {
36  const transport = new StdioServerTransport();
37  await server.connect(transport);
38  logger.info("MCP server started with logging and monitoring");
39}
40main().catch(e => { logger.fatal(e, "Server failed to start"); process.exit(1); });