examples: Fix SSE streaming issue by moving logging from HTTP to MCP middlewarre (#614)

In `examples/http`, previous HTTP-level logging middleware blocked SSE
streaming because `handler.ServeHTTP()` does not return until the
connection closes for GET requests (SSE streams).
This prevented response headers from being sent to the client.

Changes:
- Replace HTTP-level logging handler with MCP middleware pattern
- Implement logging at the MCP protocol layer using mcp.Middleware
- Add middleware to server using AddReceivingMiddleware()
- Simplify main.go by removing HTTP handler wrapping

This allows SSE streams to work properly while still providing detailed
logging for all MCP protocol-level method calls.

Fixes #632
This commit is contained in:
Spring_MT 2025-11-12 01:56:52 +09:00 • committed by GitHub
commit 35dfcf21c9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 46 additions and 43 deletions

View file

@ -5,47 +5,49 @@
package main package main
import ( import (
"context"
"log" "log"
"net/http"
"time" "time"
"github.com/modelcontextprotocol/go-sdk/mcp"
) )
// responseWriter wraps http.ResponseWriter to capture the status code. // createLoggingMiddleware creates an MCP middleware that logs method calls.
type responseWriter struct { func createLoggingMiddleware() mcp.Middleware {
http.ResponseWriter return func(next mcp.MethodHandler) mcp.MethodHandler {
statusCode int return func(
} ctx context.Context,
method string,
func (rw *responseWriter) WriteHeader(code int) { req mcp.Request,
rw.statusCode = code ) (mcp.Result, error) {
rw.ResponseWriter.WriteHeader(code) start := time.Now()
} sessionID := req.GetSession().ID()
func loggingHandler(handler http.Handler) http.Handler { // Log request details.
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { log.Printf("[REQUEST] Session: %s | Method: %s",
start := time.Now() sessionID,
method)
// Create a response writer wrapper to capture status code.
wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK} // Call the actual handler.
result, err := next(ctx, method, req)
// Log request details.
log.Printf("[REQUEST] %s | %s | %s %s", // Log response details.
start.Format(time.RFC3339), duration := time.Since(start)
r.RemoteAddr,
r.Method, if err != nil {
r.URL.Path) log.Printf("[RESPONSE] Session: %s | Method: %s | Status: ERROR | Duration: %v | Error: %v",
sessionID,
// Call the actual handler. method,
handler.ServeHTTP(wrapped, r) duration,
err)
// Log response details. } else {
duration := time.Since(start) log.Printf("[RESPONSE] Session: %s | Method: %s | Status: OK | Duration: %v",
log.Printf("[RESPONSE] %s | %s | %s %s | Status: %d | Duration: %v", sessionID,
time.Now().Format(time.RFC3339), method,
r.RemoteAddr, duration)
r.Method, }
r.URL.Path,
wrapped.statusCode, return result, err
duration) }
}) }
} }

View file

@ -117,6 +117,9 @@ func runServer(url string) {
Version: "1.0.0", Version: "1.0.0",
}, nil) }, nil)
// Add MCP-level logging middleware.
server.AddReceivingMiddleware(createLoggingMiddleware())
// Add the cityTime tool. // Add the cityTime tool.
mcp.AddTool(server, &mcp.Tool{ mcp.AddTool(server, &mcp.Tool{
Name: "cityTime", Name: "cityTime",
@ -128,13 +131,11 @@ func runServer(url string) {
return server return server
}, nil) }, nil)
handlerWithLogging := loggingHandler(handler)
log.Printf("MCP server listening on %s", url) log.Printf("MCP server listening on %s", url)
log.Printf("Available tool: cityTime (cities: nyc, sf, boston)") log.Printf("Available tool: cityTime (cities: nyc, sf, boston)")
// Start the HTTP server with logging handler. // Start the HTTP server.
if err := http.ListenAndServe(url, handlerWithLogging); err != nil { if err := http.ListenAndServe(url, handler); err != nil {
log.Fatalf("Server failed: %v", err) log.Fatalf("Server failed: %v", err)
} }
} }