fix: disable unnessary logs in stdio mode

Author: linhdmn

bin/input.json

@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}

bin/multi-protocol-server

@@ -3,6 +3,10 @@ package logging
 
 import (
 	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
 
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
@@ -40,33 +44,92 @@ type Config struct {
 
 // DefaultConfig returns a default configuration for the logger
 func DefaultConfig() Config {
+	// If in stdio mode, default to stderr instead of stdout
+	outputs := []string{"stdout"}
+	if isStdioMode() {
+		outputs = getStdioSafeOutputs()
+	}
+
 	return Config{
 		Level:       InfoLevel,
 		Development: false,
-		OutputPaths: []string{"stdout"},
+		OutputPaths: outputs,
 	}
 }
 
 // DevelopmentConfig returns a development configuration for the logger
 func DevelopmentConfig() Config {
+	// If in stdio mode, default to stderr instead of stdout
+	outputs := []string{"stdout"}
+	if isStdioMode() {
+		outputs = getStdioSafeOutputs()
+	}
+
 	return Config{
 		Level:       DebugLevel,
 		Development: true,
-		OutputPaths: []string{"stdout"},
+		OutputPaths: outputs,
 	}
 }
 
 // ProductionConfig returns a production configuration for the logger
 func ProductionConfig() Config {
+	// If in stdio mode, default to stderr instead of stdout
+	outputs := []string{"stdout"}
+	if isStdioMode() {
+		outputs = getStdioSafeOutputs()
+	}
+
 	return Config{
 		Level:       InfoLevel,
 		Development: false,
-		OutputPaths: []string{"stdout"},
+		OutputPaths: outputs,
+	}
+}
+
+// isStdioMode checks if we're running in stdio mode
+func isStdioMode() bool {
+	mode := os.Getenv("TRANSPORT_MODE")
+	return mode == "stdio"
+}
+
+// getStdioSafeOutputs returns outputs that are safe for stdio mode
+func getStdioSafeOutputs() []string {
+	// In stdio mode, never use stdout as it will interfere with JSON-RPC
+	// Try to use a log file, fall back to stderr
+	if os.Getenv("MCP_DISABLE_LOGGING") == "true" {
+		// If logging is disabled, use /dev/null or nul for Windows
+		return []string{"stderr"}
 	}
+
+	// Create a log file in the logs directory
+	logsDir := "logs"
+	if _, err := os.Stat(logsDir); os.IsNotExist(err) {
+		os.MkdirAll(logsDir, 0755)
+	}
+
+	// Create a timestamped log file
+	timestamp := time.Now().Format("20060102-150405")
+	logFile := filepath.Join(logsDir, fmt.Sprintf("cortex-%s.log", timestamp))
+
+	return []string{logFile, "stderr"}
 }
 
 // New creates a new logger with the given configuration
 func New(config Config) (*Logger, error) {
+	// If in stdio mode, force logs to NOT go to stdout regardless of config
+	if isStdioMode() && len(config.OutputPaths) > 0 {
+		// Replace any stdout with safe outputs
+		safeOutputs := getStdioSafeOutputs()
+		for _, path := range config.OutputPaths {
+			if path == "stdout" {
+				// In stdio mode, replace stdout with safe outputs
+				config.OutputPaths = safeOutputs
+				break
+			}
+		}
+	}
+
 	// Convert log level to zapcore level
 	var level zapcore.Level
 	switch config.Level {

bin/sse-server

@@ -88,15 +88,36 @@ func WithErrorLogger(stdLogger *log.Logger) StdioOption {
 // NewStdioServer creates a new stdio server wrapper around an MCPServer.
 // It initializes the server with a default logger that logs to stderr.
 func NewStdioServer(server *rest.MCPServer, opts ...StdioOption) *StdioServer {
-	// Create default logger - always use stderr for STDIO servers
-	defaultLogger, err := logging.New(logging.Config{
-		Level:       logging.InfoLevel,
-		Development: true,
-		OutputPaths: []string{"stderr"}, // Force stderr for all logging output
-		InitialFields: logging.Fields{
-			"component": "stdio-server",
-		},
-	})
+	// Check for environment variables that indicate logging should be disabled
+	var defaultLogger *logging.Logger
+	var err error
+
+	disableLogging := os.Getenv("MCP_DISABLE_LOGGING") == "true" ||
+		os.Getenv("DISABLE_LOGGING") == "true"
+
+	if disableLogging {
+		// Create a logger that sends nothing to stdout
+		// We'll still log to stderr for critical errors
+		defaultLogger, err = logging.New(logging.Config{
+			Level:       logging.ErrorLevel, // Only log errors
+			Development: false,
+			OutputPaths: []string{"stderr"}, // Only stderr, never stdout
+			InitialFields: logging.Fields{
+				"component": "stdio-server",
+			},
+		})
+	} else {
+		// Create default logger - always use stderr for STDIO servers
+		defaultLogger, err = logging.New(logging.Config{
+			Level:       logging.InfoLevel,
+			Development: true,
+			OutputPaths: []string{"stderr"}, // Force stderr for all logging output
+			InitialFields: logging.Fields{
+				"component": "stdio-server",
+			},
+		})
+	}
+
 	if err != nil {
 		// Fallback to a simple default logger if we can't create the structured one
 		defaultLogger = logging.Default()
@@ -222,19 +243,30 @@ func ServeStdio(server *rest.MCPServer, opts ...StdioOption) error {
 
 	go func() {
 		sig := <-sigChan
-		s.logger.Info("Received shutdown signal, stopping server...", logging.Fields{"signal": sig.String()})
+		// Only log if logging is enabled
+		if os.Getenv("MCP_DISABLE_LOGGING") != "true" && os.Getenv("DISABLE_LOGGING") != "true" {
+			s.logger.Info("Received shutdown signal, stopping server...", logging.Fields{"signal": sig.String()})
+		}
 		cancel()
 	}()
 
-	s.logger.Info("Starting MCP server in stdio mode")
+	// Only log if logging is enabled
+	if os.Getenv("MCP_DISABLE_LOGGING") != "true" && os.Getenv("DISABLE_LOGGING") != "true" {
+		s.logger.Info("Starting MCP server in stdio mode")
+	}
 
 	err := s.Listen(ctx, os.Stdin, os.Stdout)
 	if err != nil && err != context.Canceled {
+		// Always log errors, but to stderr
 		s.logger.Error("Server exited with error", logging.Fields{"error": err})
 		return err
 	}
 
-	s.logger.Info("Server shutdown complete")
+	// Only log if logging is enabled
+	if os.Getenv("MCP_DISABLE_LOGGING") != "true" && os.Getenv("DISABLE_LOGGING") != "true" {
+		s.logger.Info("Server shutdown complete")
+	}
+
 	return nil
 }
 
@@ -307,7 +339,11 @@ func (p *MessageProcessor) Process(ctx context.Context, message string) (interfa
 	// Check if this is a notification (no ID field)
 	// Notifications don't require responses
 	if baseMessage.ID == nil && strings.HasPrefix(baseMessage.Method, "notifications/") {
-		p.logger.Info("Received notification", logging.Fields{"method": baseMessage.Method})
+		// In stdio mode we must be very careful about logging
+		// Use a custom field to avoid JSON output format
+		if os.Getenv("MCP_DISABLE_LOGGING") != "true" && os.Getenv("DISABLE_LOGGING") != "true" {
+			p.logger.Info("Received notification", logging.Fields{"method": baseMessage.Method})
+		}
 		// Process notification but don't return a response
 		return nil, nil
 	}
@@ -317,7 +353,11 @@ func (p *MessageProcessor) Process(ctx context.Context, message string) (interfa
 
 	// Handle notifications with a prefix
 	if !exists && strings.HasPrefix(baseMessage.Method, "notifications/") {
-		p.logger.Info("Processed notification", logging.Fields{"method": baseMessage.Method})
+		// In stdio mode we must be very careful about logging
+		// Use a custom field to avoid JSON output format
+		if os.Getenv("MCP_DISABLE_LOGGING") != "true" && os.Getenv("DISABLE_LOGGING") != "true" {
+			p.logger.Info("Processed notification", logging.Fields{"method": baseMessage.Method})
+		}
 		return nil, nil
 	}