Add logging stack with slog adapter

internal/ghmcp/server.go

@@ -207,6 +207,7 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 		cfg.Translator,
 		github.FeatureFlags{LockdownMode: cfg.LockdownMode},
 		cfg.ContentWindowSize,
+		cfg.Logger,
 	)
 
 	// Inject dependencies into context for all tool handlers

pkg/github/dependencies.go

@@ -3,9 +3,12 @@ package github
 import (
 	"context"
 	"errors"
+	"log/slog"
 
 	"github.com/github/github-mcp-server/pkg/inventory"
 	"github.com/github/github-mcp-server/pkg/lockdown"
+	"github.com/github/github-mcp-server/pkg/observability"
+	obsvLog "github.com/github/github-mcp-server/pkg/observability/log"
 	"github.com/github/github-mcp-server/pkg/raw"
 	"github.com/github/github-mcp-server/pkg/scopes"
 	"github.com/github/github-mcp-server/pkg/translations"
@@ -77,6 +80,9 @@ type ToolDependencies interface {
 
 	// GetContentWindowSize returns the content window size for log truncation
 	GetContentWindowSize() int
+
+	// GetLogger returns the logger
+	Logger(ctx context.Context) obsvLog.Logger
 }
 
 // BaseDeps is the standard implementation of ToolDependencies for the local server.
@@ -93,6 +99,7 @@ type BaseDeps struct {
 	T                 translations.TranslationHelperFunc
 	Flags             FeatureFlags
 	ContentWindowSize int
+	Obsv              observability.Exporters
 }
 
 // NewBaseDeps creates a BaseDeps with the provided clients and configuration.
@@ -104,6 +111,7 @@ func NewBaseDeps(
 	t translations.TranslationHelperFunc,
 	flags FeatureFlags,
 	contentWindowSize int,
+	logger *slog.Logger,
 ) *BaseDeps {
 	return &BaseDeps{
 		Client:            client,
@@ -113,6 +121,7 @@ func NewBaseDeps(
 		T:                 t,
 		Flags:             flags,
 		ContentWindowSize: contentWindowSize,
+		Obsv:              observability.NewExporters(obsvLog.NewSlogLogger(logger, obsvLog.InfoLevel)),
 	}
 }
 
@@ -134,6 +143,11 @@ func (d BaseDeps) GetRawClient(_ context.Context) (*raw.Client, error) {
 // GetRepoAccessCache implements ToolDependencies.
 func (d BaseDeps) GetRepoAccessCache() *lockdown.RepoAccessCache { return d.RepoAccessCache }
 
+// GetLogger implements ToolDependencies.
+func (d BaseDeps) Logger(ctx context.Context) obsvLog.Logger {
+	return d.Obsv.Logger(ctx)
+}
+
 // GetT implements ToolDependencies.
 func (d BaseDeps) GetT() translations.TranslationHelperFunc { return d.T }
 

pkg/github/dynamic_tools_test.go

@@ -1,8 +1,10 @@
 package github
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"log/slog"
 	"testing"
 
 	"github.com/github/github-mcp-server/pkg/inventory"
@@ -128,12 +130,14 @@ func TestDynamicTools_EnableToolset(t *testing.T) {
 
 	// Create a mock server
 	server := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+	var logBuffer bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&logBuffer, nil))
 
 	// Create dynamic tool dependencies
 	deps := DynamicToolDependencies{
 		Server:    server,
 		Inventory: reg,
-		ToolDeps:  NewBaseDeps(nil, nil, nil, nil, translations.NullTranslationHelper, FeatureFlags{}, 0),
+		ToolDeps:  NewBaseDeps(nil, nil, nil, nil, translations.NullTranslationHelper, FeatureFlags{}, 0, logger),
 		T:         translations.NullTranslationHelper,
 	}
 

pkg/github/issues.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"strings"
 	"time"
@@ -1459,12 +1460,21 @@ func ListIssues(t translations.TranslationHelperFunc) inventory.ServerTool {
 				return utils.NewToolResultError(err.Error()), nil, nil
 			}
 
+			deps.Logger(ctx).Info("list_issues called",
+				slog.String("owner", owner),
+				slog.String("repo", repo),
+				slog.String("orderBy", orderBy),
+				slog.String("direction", direction),
+				slog.String("since", since),
+			)
+
 			// There are two optional parameters: since and labels.
 			var sinceTime time.Time
 			var hasSince bool
 			if since != "" {
 				sinceTime, err = parseISOTimestamp(since)
 				if err != nil {
+					deps.Logger(ctx).Info("failed to parse 'since' timestamp", slog.String("error", err.Error()))
 					return utils.NewToolResultError(fmt.Sprintf("failed to list issues: %s", err.Error())), nil, nil
 				}
 				hasSince = true

pkg/github/server_test.go

@@ -10,6 +10,8 @@ import (
 	"time"
 
 	"github.com/github/github-mcp-server/pkg/lockdown"
+	"github.com/github/github-mcp-server/pkg/observability"
+	mcpLog "github.com/github/github-mcp-server/pkg/observability/log"
 	"github.com/github/github-mcp-server/pkg/raw"
 	"github.com/github/github-mcp-server/pkg/translations"
 	"github.com/google/go-github/v79/github"
@@ -28,6 +30,7 @@ type stubDeps struct {
 	t                 translations.TranslationHelperFunc
 	flags             FeatureFlags
 	contentWindowSize int
+	obsv              observability.Exporters
 }
 
 func (s stubDeps) GetClient(ctx context.Context) (*github.Client, error) {
@@ -55,6 +58,7 @@ func (s stubDeps) GetRepoAccessCache() *lockdown.RepoAccessCache { return s.repo
 func (s stubDeps) GetT() translations.TranslationHelperFunc      { return s.t }
 func (s stubDeps) GetFlags() FeatureFlags                        { return s.flags }
 func (s stubDeps) GetContentWindowSize() int                     { return s.contentWindowSize }
+func (s stubDeps) Logger(ctx context.Context) mcpLog.Logger      { return s.obsv.Logger(ctx) }
 
 // Helper functions to create stub client functions for error testing
 func stubClientFnFromHTTP(httpClient *http.Client) func(context.Context) (*github.Client, error) {

pkg/observability/log/level.go

@@ -0,0 +1,28 @@
+package log
+
+type Level struct {
+	level string
+}
+
+var (
+	// DebugLevel causes all logs to be logged
+	DebugLevel = Level{"debug"}
+	// InfoLevel causes all logs of level info or more severe to be logged
+	InfoLevel = Level{"info"}
+	// WarnLevel causes all logs of level warn or more severe to be logged
+	WarnLevel = Level{"warn"}
+	// ErrorLevel causes all logs of level error or more severe to be logged
+	ErrorLevel = Level{"error"}
+	// FatalLevel causes only logs of level fatal to be logged
+	FatalLevel = Level{"fatal"}
+)
+
+// String returns the string representation for Level
+//
+// This is useful when trying to get the string values for Level and mapping level in other external libraries. For example:
+// ```
+// trace.SetLogLevel(kvp.String("loglevel", log.DebugLevel.String())
+// ```
+func (l Level) String() string {
+	return l.level
+}

pkg/observability/log/logger.go

@@ -0,0 +1,21 @@
+package log
+
+import (
+	"context"
+	"log/slog"
+)
+
+type Logger interface {
+	Log(ctx context.Context, level Level, msg string, fields ...slog.Attr)
+	Debug(msg string, fields ...slog.Attr)
+	Info(msg string, fields ...slog.Attr)
+	Warn(msg string, fields ...slog.Attr)
+	Error(msg string, fields ...slog.Attr)
+	Fatal(msg string, fields ...slog.Attr)
+	WithFields(fields ...slog.Attr) Logger
+	WithError(err error) Logger
+	Named(name string) Logger
+	WithLevel(level Level) Logger
+	Sync() error
+	Level() Level
+}

pkg/observability/log/noop_adapter.go

@@ -0,0 +1,62 @@
+package log
+
+import (
+	"context"
+	"log/slog"
+)
+
+type NoopLogger struct{}
+
+var _ Logger = (*NoopLogger)(nil)
+
+func NewNoopLogger() *NoopLogger {
+	return &NoopLogger{}
+}
+
+func (l *NoopLogger) Level() Level {
+	return DebugLevel
+}
+
+func (l *NoopLogger) Log(_ context.Context, _ Level, _ string, _ ...slog.Attr) {
+	// No-op
+}
+
+func (l *NoopLogger) Debug(_ string, _ ...slog.Attr) {
+	// No-op
+}
+
+func (l *NoopLogger) Info(_ string, _ ...slog.Attr) {
+	// No-op
+}
+
+func (l *NoopLogger) Warn(_ string, _ ...slog.Attr) {
+	// No-op
+}
+
+func (l *NoopLogger) Error(_ string, _ ...slog.Attr) {
+	// No-op
+}
+
+func (l *NoopLogger) Fatal(_ string, _ ...slog.Attr) {
+	// No-op
+}
+
+func (l *NoopLogger) WithFields(_ ...slog.Attr) Logger {
+	return l
+}
+
+func (l *NoopLogger) WithError(_ error) Logger {
+	return l
+}
+
+func (l *NoopLogger) Named(_ string) Logger {
+	return l
+}
+
+func (l *NoopLogger) WithLevel(_ Level) Logger {
+	return l
+}
+
+func (l *NoopLogger) Sync() error {
+	return nil
+}

pkg/observability/log/slog_adapter.go

@@ -0,0 +1,108 @@
+package log
+
+import (
+	"context"
+	"log/slog"
+)
+
+type SlogLogger struct {
+	logger *slog.Logger
+	level  Level
+}
+
+func NewSlogLogger(logger *slog.Logger, level Level) *SlogLogger {
+	return &SlogLogger{
+		logger: logger,
+		level:  level,
+	}
+}
+
+func (l *SlogLogger) Level() Level {
+	return l.level
+}
+
+func (l *SlogLogger) Log(ctx context.Context, level Level, msg string, fields ...slog.Attr) {
+	slogLevel := convertLevel(level)
+	l.logger.LogAttrs(ctx, slogLevel, msg, fields...)
+}
+
+func (l *SlogLogger) Debug(msg string, fields ...slog.Attr) {
+	l.Log(context.Background(), DebugLevel, msg, fields...)
+}
+
+func (l *SlogLogger) Info(msg string, fields ...slog.Attr) {
+	l.Log(context.Background(), InfoLevel, msg, fields...)
+}
+
+func (l *SlogLogger) Warn(msg string, fields ...slog.Attr) {
+	l.Log(context.Background(), WarnLevel, msg, fields...)
+}
+
+func (l *SlogLogger) Error(msg string, fields ...slog.Attr) {
+	l.Log(context.Background(), ErrorLevel, msg, fields...)
+}
+
+func (l *SlogLogger) Fatal(msg string, fields ...slog.Attr) {
+	l.Log(context.Background(), FatalLevel, msg, fields...)
+	// Sync to ensure the log message is flushed before panic
+	_ = l.Sync()
+	panic("fatal: " + msg)
+}
+
+func (l *SlogLogger) WithFields(fields ...slog.Attr) Logger {
+	fieldKvPairs := make([]any, 0, len(fields)*2)
+	for _, attr := range fields {
+		k, v := attr.Key, attr.Value
+		fieldKvPairs = append(fieldKvPairs, k, v.Any())
+	}
+	return &SlogLogger{
+		logger: l.logger.With(fieldKvPairs...),
+		level:  l.level,
+	}
+}
+
+func (l *SlogLogger) WithError(err error) Logger {
+	if err == nil {
+		return l
+	}
+	return &SlogLogger{
+		logger: l.logger.With("error", err.Error()),
+		level:  l.level,
+	}
+}
+
+func (l *SlogLogger) Named(name string) Logger {
+	return &SlogLogger{
+		logger: l.logger.With("logger", name),
+		level:  l.level,
+	}
+}
+
+func (l *SlogLogger) WithLevel(level Level) Logger {
+	return &SlogLogger{
+		logger: l.logger,
+		level:  level,
+	}
+}
+
+func (l *SlogLogger) Sync() error {
+	// Slog does not require syncing
+	return nil
+}
+
+func convertLevel(level Level) slog.Level {
+	switch level {
+	case DebugLevel:
+		return slog.LevelDebug
+	case InfoLevel:
+		return slog.LevelInfo
+	case WarnLevel:
+		return slog.LevelWarn
+	case ErrorLevel:
+		return slog.LevelError
+	case FatalLevel:
+		return slog.LevelError
+	default:
+		return slog.LevelInfo
+	}
+}