🔧 Consolidate logger setup in client transports

changelog.md

@@ -239,4 +239,19 @@ Replaced custom caller marshaler with zerolog's built-in Caller() for simpler an
 Consolidated logging setup to use a consistent logger throughout the application:
 - Set up global logger with console writer in main.go
 - Removed duplicate logger creation in createClient
-- Ensured client.go uses the local logger consistently
+- Ensured client.go uses the local logger consistently
+
+# Server Logger Consolidation
+
+Consolidated logging setup in the server components:
+- Set up global logger with console writer in server's main.go
+- Removed duplicate logger creation in server startup
+- Ensured consistent logger propagation through server components
+
+# Client Transport Logger Consolidation
+
+Consolidated logging setup in client transports:
+- Updated SSE transport to use passed logger instead of creating its own
+- Updated stdio transport to use passed logger instead of creating its own
+- Modified transport constructors to accept logger parameter
+- Ensured consistent logger propagation through all client components

cmd/mcp-client/main.go

@@ -326,13 +326,13 @@ func createClient(ctx context.Context) (*client.Client, error) {
 			return nil, fmt.Errorf("command is required for command transport")
 		}
 		log.Debug().Msgf("Creating command transport with args: %v", cmdArgs)
-		t, err = client.NewCommandStdioTransport(cmdArgs[0], cmdArgs[1:]...)
+		t, err = client.NewCommandStdioTransport(log.Logger, cmdArgs[0], cmdArgs[1:]...)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create command transport: %w", err)
 		}
 	case "sse":
 		log.Debug().Msgf("Creating SSE transport with server URL: %s", serverURL)
-		t = client.NewSSETransport(serverURL)
+		t = client.NewSSETransport(serverURL, log.Logger)
 	default:
 		return nil, fmt.Errorf("invalid transport type: %s", transport)
 	}

cmd/mcp-server/main.go

@@ -49,14 +49,19 @@ providing a framework for building MCP servers and clients.`,
 				fmt.Fprintf(os.Stderr, "Invalid log level %s, defaulting to info\n", logLevel)
 				level = zerolog.InfoLevel
 			}
+
+			// Set up console writer for colored output
+			consoleWriter := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+			logger := zerolog.New(consoleWriter).With().Timestamp()
+			if withCaller {
+				logger = logger.Caller()
+			}
+			log.Logger = logger.Logger()
+
 			zerolog.SetGlobalLevel(level)
 			if debug {
 				zerolog.SetGlobalLevel(zerolog.DebugLevel)
 			}
-			if withCaller {
-				log.Debug().Msgf("Setting caller")
-				log.Logger = log.With().Caller().Logger()
-			}
 		},
 	}
 
@@ -75,12 +80,8 @@ Available transports:
 - stdio: Standard input/output transport (default)
 - sse: Server-Sent Events transport over HTTP`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// Use ConsoleWriter for colored output
-			consoleWriter := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
-			logger := zerolog.New(consoleWriter).With().Timestamp().Logger()
-
 			// Create server
-			srv := server.NewServer(logger)
+			srv := server.NewServer(log.Logger)
 			promptRegistry := prompts.NewRegistry()
 			resourceRegistry := resources.NewRegistry()
 			toolRegistry := tools.NewRegistry()
@@ -114,7 +115,7 @@ Available transports:
 
 			tool, err := tools.NewToolImpl("echo", "Echo the input arguments", json.RawMessage(schemaJson))
 			if err != nil {
-				logger.Error().Err(err).Msg("Error creating tool")
+				log.Error().Err(err).Msg("Error creating tool")
 				return err
 			}
 			toolRegistry.RegisterToolWithHandler(
@@ -151,10 +152,10 @@ Available transports:
 				var err error
 				switch transport {
 				case "stdio":
-					logger.Info().Msg("Starting server with stdio transport")
+					log.Info().Msg("Starting server with stdio transport")
 					err = srv.StartStdio(ctx)
 				case "sse":
-					logger.Info().Int("port", port).Msg("Starting server with SSE transport")
+					log.Info().Int("port", port).Msg("Starting server with SSE transport")
 					err = srv.StartSSE(ctx, port)
 				default:
 					err = fmt.Errorf("invalid transport type: %s", transport)
@@ -166,23 +167,23 @@ Available transports:
 			select {
 			case err := <-errChan:
 				if err != nil && err != io.EOF {
-					logger.Error().Err(err).Msg("Server error")
+					log.Error().Err(err).Msg("Server error")
 					return err
 				}
 				return nil
 			case sig := <-sigChan:
-				logger.Info().Str("signal", sig.String()).Msg("Received signal, initiating graceful shutdown")
+				log.Info().Str("signal", sig.String()).Msg("Received signal, initiating graceful shutdown")
 				// Cancel context to initiate shutdown
 				cancel()
 				// Create a timeout context for shutdown
 				shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
 				defer shutdownCancel()
 				if err := srv.Stop(shutdownCtx); err != nil {
-					logger.Error().Err(err).Msg("Error during shutdown")
+					log.Error().Err(err).Msg("Error during shutdown")
 					return err
 
 				}
-				logger.Info().Msg("Server stopped gracefully")
+				log.Info().Msg("Server stopped gracefully")
 				return nil
 			}
 		},

pkg/client/sse.go

@@ -7,13 +7,11 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"sync"
 
 	"github.com/go-go-golems/go-go-mcp/pkg/protocol"
 	"github.com/r3labs/sse/v2"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 )
 
 // SSETransport implements Transport using Server-Sent Events
@@ -29,13 +27,13 @@ type SSETransport struct {
 }
 
 // NewSSETransport creates a new SSE transport
-func NewSSETransport(baseURL string) *SSETransport {
+func NewSSETransport(baseURL string, logger zerolog.Logger) *SSETransport {
 	return &SSETransport{
 		baseURL:   baseURL,
 		client:    &http.Client{},
 		sseClient: sse.NewClient(baseURL + "/sse"),
 		events:    make(chan *sse.Event),
-		logger:    zerolog.New(zerolog.ConsoleWriter{Out: os.Stderr}).With().Timestamp().Logger(),
+		logger:    logger,
 	}
 }
 
@@ -85,7 +83,7 @@ func (t *SSETransport) Send(ctx context.Context, request *protocol.Request) (*pr
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
 		body, _ := io.ReadAll(resp.Body)
 		t.logger.Error().
 			Int("status", resp.StatusCode).
@@ -137,7 +135,7 @@ func (t *SSETransport) initializeSSE(ctx context.Context) error {
 	go func() {
 		defer cancel()
 
-		log.Debug().Msgf("Subscribing to SSE")
+		t.logger.Debug().Msg("Subscribing to SSE")
 		err := t.sseClient.SubscribeWithContext(subCtx, "", func(msg *sse.Event) {
 			t.logger.Debug().
 				Str("event", string(msg.Event)).

pkg/client/stdio.go

@@ -25,19 +25,18 @@ type StdioTransport struct {
 }
 
 // NewStdioTransport creates a new stdio transport
-func NewStdioTransport() *StdioTransport {
+func NewStdioTransport(logger zerolog.Logger) *StdioTransport {
 	return &StdioTransport{
 		scanner: bufio.NewScanner(os.Stdin),
 		writer:  json.NewEncoder(os.Stdout),
-		logger:  zerolog.New(zerolog.ConsoleWriter{Out: os.Stderr}).With().Timestamp().Logger(),
+		logger:  logger,
 	}
 }
 
 // NewCommandStdioTransport creates a new stdio transport that launches a command
-func NewCommandStdioTransport(command string, args ...string) (*StdioTransport, error) {
+func NewCommandStdioTransport(logger zerolog.Logger, command string, args ...string) (*StdioTransport, error) {
 	cmd := exec.Command(command, args...)
 
-	logger := zerolog.New(zerolog.ConsoleWriter{Out: os.Stderr}).With().Timestamp().Logger()
 	logger.Debug().
 		Str("command", command).
 		Strs("args", args).