@tigerdata/mcp-boilerplate 0.2.1 → 0.4.0

package/dist/cliEntrypoint.js

@@ -17,7 +17,8 @@ export async function cliEntrypoint(stdioEntrypoint, httpEntrypoint, instrumenta
                 let cleanup;
                 if (args.includes('--instrument') ||
                     process.env.INSTRUMENT === 'true') {
-                    ({ cleanup } = await import(instrumentation));
+                    const { instrument } = await import(instrumentation);
+                    ({ cleanup } = instrument());
                 }
                 // Import and run the HTTP server
                 const { registerCleanupFn } = await import(httpEntrypoint);

package/dist/http/mcp.js

@@ -1,9 +1,13 @@
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { trace, context as otelContext, propagation, SpanKind, SpanStatusCode, } from '@opentelemetry/api';
+import { ATTR_HTTP_RESPONSE_STATUS_CODE } from '@opentelemetry/semantic-conventions';
 import { Router } from 'express';
 import { randomUUID } from 'node:crypto';
 import getRawBody from 'raw-body';
 import { log } from '../logger.js';
+const name = process.env.OTEL_SERVICE_NAME;
+const tracer = trace.getTracer(name ? `${name}.router.mcp` : 'router.mcp');
 export const mcpRouterFactory = (context, createServer, { name, stateful = true, } = {}) => {
     const router = Router();
     const transports = new Map();
@@ -75,24 +79,43 @@ export const mcpRouterFactory = (context, createServer, { name, stateful = true,
         await transport.handleRequest(req, res, body);
     };
     router.post('/', async (req, res) => {
-        try {
-            await (stateful
-                ? handleStatefulRequest(req, res)
-                : handleStatelessRequest(req, res));
+        let traceContext = otelContext.active();
+        if (req.headers.traceparent) {
+            // Some MCP clients (e.g. pydantic) pass the parent trace context
+            traceContext = propagation.extract(traceContext, {
+                traceparent: req.headers.traceparent,
+            });
         }
-        catch (error) {
-            log.error('Error handling MCP request:', error);
-            if (!res.headersSent) {
-                res.status(500).json({
-                    jsonrpc: '2.0',
-                    error: {
-                        code: -32603,
-                        message: 'Internal server error',
-                    },
-                    id: null,
+        await tracer.startActiveSpan('mcp.http.post', { kind: SpanKind.SERVER }, traceContext, async (span) => {
+            try {
+                await (stateful
+                    ? handleStatefulRequest(req, res)
+                    : handleStatelessRequest(req, res));
+                span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, res.statusCode);
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            catch (error) {
+                log.error('Error handling MCP request:', error);
+                span.recordException(error);
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error.message,
                 });
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: 'Internal server error',
+                        },
+                        id: null,
+                    });
+                }
             }
-        }
+            finally {
+                span.end();
+            }
+        });
     });
     // Reusable handler for GET and DELETE requests
     const handleSessionRequest = async (req, res) => {

package/dist/instrumentation.d.ts

@@ -1,3 +1,13 @@
 import { NodeSDK } from '@opentelemetry/sdk-node';
-export declare const sdk: NodeSDK;
-export declare const cleanup: () => Promise<void>;
+import { InstrumentationConfigMap } from '@opentelemetry/auto-instrumentations-node';
+import type { Instrumentation } from '@opentelemetry/instrumentation';
+interface Options {
+    environment?: string;
+    instrumentations?: Instrumentation[];
+    nodeAutoInstrumentationsOptions?: InstrumentationConfigMap;
+}
+export declare const instrument: (options?: Options) => {
+    cleanup: () => Promise<void>;
+    sdk: NodeSDK;
+};
+export {};

package/dist/instrumentation.js

@@ -2,57 +2,67 @@ import { NodeSDK } from '@opentelemetry/sdk-node';
 import { resourceFromAttributes } from '@opentelemetry/resources';
 import { OTLPTraceExporter as GrpcTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
 import { OTLPTraceExporter as HttpTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { getNodeAutoInstrumentations, } from '@opentelemetry/auto-instrumentations-node';
 import { BatchSpanProcessor, } from '@opentelemetry/sdk-trace-base';
 import { BatchLogRecordProcessor, } from '@opentelemetry/sdk-logs';
 import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 import { log } from './logger.js';
-const spanProcessors = [];
-const logRecordProcessors = [];
-if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
-    spanProcessors.push(new BatchSpanProcessor(new GrpcTraceExporter()));
-}
-if (process.env.JAEGER_TRACES_ENDPOINT) {
-    spanProcessors.push(new BatchSpanProcessor(new GrpcTraceExporter({
-        url: process.env.JAEGER_TRACES_ENDPOINT,
-    })));
-}
-if (process.env.LOGFIRE_TRACES_ENDPOINT) {
-    spanProcessors.push(new BatchSpanProcessor(new HttpTraceExporter({
-        url: process.env.LOGFIRE_TRACES_ENDPOINT,
-        headers: process.env.LOGFIRE_TOKEN
-            ? { Authorization: `Bearer ${process.env.LOGFIRE_TOKEN}` }
-            : {},
-    })));
-}
-if (process.env.LOGFIRE_LOGS_ENDPOINT) {
-    logRecordProcessors.push(new BatchLogRecordProcessor(new OTLPLogExporter({
-        url: process.env.LOGFIRE_LOGS_ENDPOINT,
-        headers: process.env.LOGFIRE_TOKEN
-            ? { Authorization: `Bearer ${process.env.LOGFIRE_TOKEN}` }
-            : {},
-    })));
-}
-export const sdk = new NodeSDK({
-    instrumentations: [getNodeAutoInstrumentations()],
-    spanProcessors,
-    logRecordProcessors,
-    resource: resourceFromAttributes({
-        'deployment.environment.name': process.env.LOGFIRE_ENVIRONMENT || process.env.NODE_ENV || 'development',
-        'service.instance.id': process.env.HOSTNAME,
-    }),
-});
-// Initialize the SDK and register with the OpenTelemetry API
-sdk.start();
-log.info('OpenTelemetry initialized');
-export const cleanup = async () => {
-    try {
-        await Promise.all(spanProcessors.map((sp) => sp.shutdown()));
-        await Promise.all(logRecordProcessors.map((lp) => lp.shutdown()));
-        await sdk.shutdown();
-        log.info('OpenTelemetry terminated');
+export const instrument = (options = {}) => {
+    const spanProcessors = [];
+    const logRecordProcessors = [];
+    if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+        spanProcessors.push(new BatchSpanProcessor(new GrpcTraceExporter()));
     }
-    catch (error) {
-        log.error('Error terminating OpenTelemetry', error);
+    if (process.env.JAEGER_TRACES_ENDPOINT) {
+        spanProcessors.push(new BatchSpanProcessor(new GrpcTraceExporter({
+            url: process.env.JAEGER_TRACES_ENDPOINT,
+        })));
     }
+    if (process.env.LOGFIRE_TRACES_ENDPOINT) {
+        spanProcessors.push(new BatchSpanProcessor(new HttpTraceExporter({
+            url: process.env.LOGFIRE_TRACES_ENDPOINT,
+            headers: process.env.LOGFIRE_TOKEN
+                ? { Authorization: `Bearer ${process.env.LOGFIRE_TOKEN}` }
+                : {},
+        })));
+    }
+    if (process.env.LOGFIRE_LOGS_ENDPOINT) {
+        logRecordProcessors.push(new BatchLogRecordProcessor(new OTLPLogExporter({
+            url: process.env.LOGFIRE_LOGS_ENDPOINT,
+            headers: process.env.LOGFIRE_TOKEN
+                ? { Authorization: `Bearer ${process.env.LOGFIRE_TOKEN}` }
+                : {},
+        })));
+    }
+    const sdk = new NodeSDK({
+        instrumentations: options.instrumentations || [
+            getNodeAutoInstrumentations(options.nodeAutoInstrumentationsOptions),
+        ],
+        spanProcessors,
+        logRecordProcessors,
+        resource: resourceFromAttributes({
+            'deployment.environment.name': options.environment ||
+                process.env.LOGFIRE_ENVIRONMENT ||
+                process.env.NODE_ENV ||
+                'development',
+            'service.instance.id': process.env.HOSTNAME,
+        }),
+    });
+    // Initialize the SDK and register with the OpenTelemetry API
+    sdk.start();
+    log.info('OpenTelemetry initialized');
+    return {
+        cleanup: async () => {
+            try {
+                await Promise.all(spanProcessors.map((sp) => sp.shutdown()));
+                await Promise.all(logRecordProcessors.map((lp) => lp.shutdown()));
+                await sdk.shutdown();
+                log.info('OpenTelemetry terminated');
+            }
+            catch (error) {
+                log.error('Error terminating OpenTelemetry', error);
+            }
+        },
+        sdk,
+    };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigerdata/mcp-boilerplate",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "MCP boilerplate code for Node.js",
   "license": "Apache-2.0",
   "author": "TigerData",
@@ -41,6 +41,7 @@
     "@opentelemetry/sdk-metrics": "^2.2.0",
     "@opentelemetry/sdk-node": "^0.207.0",
     "@opentelemetry/sdk-trace-node": "^2.2.0",
+    "@opentelemetry/semantic-conventions": "^1.37.0",
     "express": "^5.1.0",
     "raw-body": "^3.0.1",
     "zod": "^3.23.8"