From 4938a506601812abe9a5328c18b6ba2d2cf1c65b Mon Sep 17 00:00:00 2001 From: Adam Holt Date: Thu, 11 Dec 2025 14:42:31 +0100 Subject: [PATCH 1/4] Add logging stack with slog adapter This allows us to have a deeper observability stack in the MCP server, particularly for surfacing logging in the remote MCP server. --- internal/ghmcp/server.go | 6 ++ pkg/github/issues.go | 6 +- pkg/github/tools.go | 14 +++- pkg/observability/log/level.go | 29 ++++++++ pkg/observability/log/log.go | 21 ++++++ pkg/observability/log/noop_adapter.go | 62 ++++++++++++++++ pkg/observability/log/slog_adapter.go | 103 ++++++++++++++++++++++++++ pkg/observability/observability.go | 15 ++++ 8 files changed, 253 insertions(+), 3 deletions(-) create mode 100644 pkg/observability/log/level.go create mode 100644 pkg/observability/log/log.go create mode 100644 pkg/observability/log/noop_adapter.go create mode 100644 pkg/observability/log/slog_adapter.go create mode 100644 pkg/observability/observability.go diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go index f4e67f264..e599c029d 100644 --- a/internal/ghmcp/server.go +++ b/internal/ghmcp/server.go @@ -17,6 +17,8 @@ import ( "github.com/github/github-mcp-server/pkg/github" "github.com/github/github-mcp-server/pkg/lockdown" mcplog "github.com/github/github-mcp-server/pkg/log" + "github.com/github/github-mcp-server/pkg/observability" + "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" gogithub "github.com/google/go-github/v79/github" @@ -150,6 +152,9 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) { ghServer.AddReceivingMiddleware(addGitHubAPIErrorToContext) ghServer.AddReceivingMiddleware(addUserAgentsMiddleware(cfg, restClient, gqlHTTPClient)) + slogAdapter := log.NewSlogLogger(cfg.Logger, log.InfoLevel) + obsv := observability.NewExporters(slogAdapter) + // Create default toolsets tsg := github.DefaultToolsetGroup( cfg.ReadOnly, @@ -160,6 +165,7 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) { cfg.ContentWindowSize, github.FeatureFlags{LockdownMode: cfg.LockdownMode}, repoAccessCache, + obsv, ) // Enable and register toolsets if configured diff --git a/pkg/github/issues.go b/pkg/github/issues.go index 46111a4d6..52a7ed687 100644 --- a/pkg/github/issues.go +++ b/pkg/github/issues.go @@ -5,12 +5,14 @@ import ( "encoding/json" "fmt" "io" + "log/slog" "net/http" "strings" "time" ghErrors "github.com/github/github-mcp-server/pkg/errors" "github.com/github/github-mcp-server/pkg/lockdown" + "github.com/github/github-mcp-server/pkg/observability" "github.com/github/github-mcp-server/pkg/sanitize" "github.com/github/github-mcp-server/pkg/translations" "github.com/github/github-mcp-server/pkg/utils" @@ -229,7 +231,7 @@ func fragmentToIssue(fragment IssueFragment) *github.Issue { } // IssueRead creates a tool to get details of a specific issue in a GitHub repository. -func IssueRead(getClient GetClientFn, getGQLClient GetGQLClientFn, cache *lockdown.RepoAccessCache, t translations.TranslationHelperFunc, flags FeatureFlags) (mcp.Tool, mcp.ToolHandlerFor[map[string]any, any]) { +func IssueRead(getClient GetClientFn, getGQLClient GetGQLClientFn, cache *lockdown.RepoAccessCache, t translations.TranslationHelperFunc, flags FeatureFlags, obsv *observability.Exporters) (mcp.Tool, mcp.ToolHandlerFor[map[string]any, any]) { schema := &jsonschema.Schema{ Type: "object", Properties: map[string]*jsonschema.Schema{ @@ -304,6 +306,8 @@ Options are: return utils.NewToolResultErrorFromErr("failed to get GitHub graphql client", err), nil, nil } + obsv.Logger.Info("deciding issue read method", slog.String("owner", owner), slog.String("method", method)) + switch method { case "get": result, err := GetIssue(ctx, client, cache, owner, repo, issueNumber, flags) diff --git a/pkg/github/tools.go b/pkg/github/tools.go index d37af98b8..1e3a0f66a 100644 --- a/pkg/github/tools.go +++ b/pkg/github/tools.go @@ -6,6 +6,7 @@ import ( "strings" "github.com/github/github-mcp-server/pkg/lockdown" + "github.com/github/github-mcp-server/pkg/observability" "github.com/github/github-mcp-server/pkg/raw" "github.com/github/github-mcp-server/pkg/toolsets" "github.com/github/github-mcp-server/pkg/translations" @@ -160,7 +161,16 @@ func GetDefaultToolsetIDs() []string { } } -func DefaultToolsetGroup(readOnly bool, getClient GetClientFn, getGQLClient GetGQLClientFn, getRawClient raw.GetRawClientFn, t translations.TranslationHelperFunc, contentWindowSize int, flags FeatureFlags, cache *lockdown.RepoAccessCache) *toolsets.ToolsetGroup { +func DefaultToolsetGroup(readOnly bool, + getClient GetClientFn, + getGQLClient GetGQLClientFn, + getRawClient raw.GetRawClientFn, + t translations.TranslationHelperFunc, + contentWindowSize int, + flags FeatureFlags, + cache *lockdown.RepoAccessCache, + obsv *observability.Exporters, +) *toolsets.ToolsetGroup { tsg := toolsets.NewToolsetGroup(readOnly) // Define all available features with their default state (disabled) @@ -200,7 +210,7 @@ func DefaultToolsetGroup(readOnly bool, getClient GetClientFn, getGQLClient GetG ) issues := toolsets.NewToolset(ToolsetMetadataIssues.ID, ToolsetMetadataIssues.Description). AddReadTools( - toolsets.NewServerTool(IssueRead(getClient, getGQLClient, cache, t, flags)), + toolsets.NewServerTool(IssueRead(getClient, getGQLClient, cache, t, flags, obsv)), toolsets.NewServerTool(SearchIssues(getClient, t)), toolsets.NewServerTool(ListIssues(getGQLClient, t)), toolsets.NewServerTool(ListIssueTypes(getClient, t)), diff --git a/pkg/observability/log/level.go b/pkg/observability/log/level.go new file mode 100644 index 000000000..878bb8461 --- /dev/null +++ b/pkg/observability/log/level.go @@ -0,0 +1,29 @@ +package log + +// Level represents the log level, from debug to fatal +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 +} diff --git a/pkg/observability/log/log.go b/pkg/observability/log/log.go new file mode 100644 index 000000000..6b7fb6ab6 --- /dev/null +++ b/pkg/observability/log/log.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 +} diff --git a/pkg/observability/log/noop_adapter.go b/pkg/observability/log/noop_adapter.go new file mode 100644 index 000000000..391efd44e --- /dev/null +++ b/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(ctx context.Context, level Level, msg string, fields ...slog.Attr) { + // No-op +} + +func (l *NoopLogger) Debug(msg string, fields ...slog.Attr) { + // No-op +} + +func (l *NoopLogger) Info(msg string, fields ...slog.Attr) { + // No-op +} + +func (l *NoopLogger) Warn(msg string, fields ...slog.Attr) { + // No-op +} + +func (l *NoopLogger) Error(msg string, fields ...slog.Attr) { + // No-op +} + +func (l *NoopLogger) Fatal(msg string, fields ...slog.Attr) { + // No-op +} + +func (l *NoopLogger) WithFields(fields ...slog.Attr) Logger { + return l +} + +func (l *NoopLogger) WithError(err error) Logger { + return l +} + +func (l *NoopLogger) Named(name string) Logger { + return l +} + +func (l *NoopLogger) WithLevel(level Level) Logger { + return l +} + +func (l *NoopLogger) Sync() error { + return nil +} diff --git a/pkg/observability/log/slog_adapter.go b/pkg/observability/log/slog_adapter.go new file mode 100644 index 000000000..642ca89c2 --- /dev/null +++ b/pkg/observability/log/slog_adapter.go @@ -0,0 +1,103 @@ +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...) + panic("fatal log called") +} + +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 { + 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 + } +} diff --git a/pkg/observability/observability.go b/pkg/observability/observability.go new file mode 100644 index 000000000..01d75fe80 --- /dev/null +++ b/pkg/observability/observability.go @@ -0,0 +1,15 @@ +package observability + +import ( + "github.com/github/github-mcp-server/pkg/observability/log" +) + +type Exporters struct { + Logger log.Logger +} + +func NewExporters(logger log.Logger) *Exporters { + return &Exporters{ + Logger: logger, + } +} From e10ff3e1c61e4680118747e1a8e7b902258bf20b Mon Sep 17 00:00:00 2001 From: Adam Holt Date: Thu, 11 Dec 2025 15:12:39 +0100 Subject: [PATCH 2/4] Update tests. --- pkg/github/issues_test.go | 43 +++++++++++++++++++++++++++++++-------- 1 file changed, 35 insertions(+), 8 deletions(-) diff --git a/pkg/github/issues_test.go b/pkg/github/issues_test.go index 48901ccdc..4e2fb90c9 100644 --- a/pkg/github/issues_test.go +++ b/pkg/github/issues_test.go @@ -14,6 +14,8 @@ import ( "github.com/github/github-mcp-server/internal/githubv4mock" "github.com/github/github-mcp-server/internal/toolsnaps" "github.com/github/github-mcp-server/pkg/lockdown" + ghMcpObsv "github.com/github/github-mcp-server/pkg/observability" + ghMcpLogger "github.com/github/github-mcp-server/pkg/observability/log" "github.com/github/github-mcp-server/pkg/translations" "github.com/google/go-github/v79/github" "github.com/google/jsonschema-go/jsonschema" @@ -124,7 +126,9 @@ func Test_GetIssue(t *testing.T) { // Verify tool definition once mockClient := github.NewClient(nil) defaultGQLClient := githubv4.NewClient(nil) - tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(defaultGQLClient), repoAccessCache, translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false})) + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(defaultGQLClient), repoAccessCache, translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false}), obsv) require.NoError(t, toolsnaps.Test(tool.Name, tool)) assert.Equal(t, "issue_read", tool.Name) @@ -331,7 +335,7 @@ func Test_GetIssue(t *testing.T) { } flags := stubFeatureFlags(map[string]bool{"lockdown-mode": tc.lockdownEnabled}) - _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), cache, translations.NullTranslationHelper, flags) + _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), cache, translations.NullTranslationHelper, flags, obsv) request := createMCPRequest(tc.requestArgs) result, _, err := handler(context.Background(), &request, tc.requestArgs) @@ -1833,7 +1837,11 @@ func Test_GetIssueComments(t *testing.T) { // Verify tool definition once mockClient := github.NewClient(nil) gqlClient := githubv4.NewClient(nil) - tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false})) + + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + + tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false}), obsv) require.NoError(t, toolsnaps.Test(tool.Name, tool)) assert.Equal(t, "issue_read", tool.Name) @@ -1984,7 +1992,10 @@ func Test_GetIssueComments(t *testing.T) { } cache := stubRepoAccessCache(gqlClient, 15*time.Minute) flags := stubFeatureFlags(map[string]bool{"lockdown-mode": tc.lockdownEnabled}) - _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), cache, translations.NullTranslationHelper, flags) + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + + _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), cache, translations.NullTranslationHelper, flags, obsv) // Create call request request := createMCPRequest(tc.requestArgs) @@ -2024,7 +2035,11 @@ func Test_GetIssueLabels(t *testing.T) { // Verify tool definition mockGQClient := githubv4.NewClient(nil) mockClient := github.NewClient(nil) - tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(mockGQClient), stubRepoAccessCache(mockGQClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false})) + + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + + tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(mockGQClient), stubRepoAccessCache(mockGQClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false}), obsv) require.NoError(t, toolsnaps.Test(tool.Name, tool)) assert.Equal(t, "issue_read", tool.Name) @@ -2099,7 +2114,11 @@ func Test_GetIssueLabels(t *testing.T) { t.Run(tc.name, func(t *testing.T) { gqlClient := githubv4.NewClient(tc.mockedClient) client := github.NewClient(nil) - _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false})) + + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + + _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false}), obsv) request := createMCPRequest(tc.requestArgs) result, _, err := handler(context.Background(), &request, tc.requestArgs) @@ -2790,7 +2809,11 @@ func Test_GetSubIssues(t *testing.T) { // Verify tool definition once mockClient := github.NewClient(nil) gqlClient := githubv4.NewClient(nil) - tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false})) + + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + + tool, _ := IssueRead(stubGetClientFn(mockClient), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false}), obsv) require.NoError(t, toolsnaps.Test(tool.Name, tool)) assert.Equal(t, "issue_read", tool.Name) @@ -2987,7 +3010,11 @@ func Test_GetSubIssues(t *testing.T) { // Setup client with mock client := github.NewClient(tc.mockedClient) gqlClient := githubv4.NewClient(nil) - _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false})) + + nilLogger := ghMcpLogger.NewNoopLogger() + obsv := ghMcpObsv.NewExporters(nilLogger) + + _, handler := IssueRead(stubGetClientFn(client), stubGetGQLClientFn(gqlClient), stubRepoAccessCache(gqlClient, 15*time.Minute), translations.NullTranslationHelper, stubFeatureFlags(map[string]bool{"lockdown-mode": false}), obsv) // Create call request request := createMCPRequest(tc.requestArgs) From cfda0353e7c7fc22240fe8e93402f3750297b3f9 Mon Sep 17 00:00:00 2001 From: Adam Holt Date: Thu, 11 Dec 2025 15:20:17 +0100 Subject: [PATCH 3/4] Mock out the observability exporters when generating docs --- cmd/github-mcp-server/generate_docs.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/cmd/github-mcp-server/generate_docs.go b/cmd/github-mcp-server/generate_docs.go index 87c9c0514..62d1e8bea 100644 --- a/cmd/github-mcp-server/generate_docs.go +++ b/cmd/github-mcp-server/generate_docs.go @@ -11,6 +11,8 @@ import ( "github.com/github/github-mcp-server/pkg/github" "github.com/github/github-mcp-server/pkg/lockdown" + "github.com/github/github-mcp-server/pkg/observability" + "github.com/github/github-mcp-server/pkg/observability/log" "github.com/github/github-mcp-server/pkg/raw" "github.com/github/github-mcp-server/pkg/toolsets" "github.com/github/github-mcp-server/pkg/translations" @@ -67,7 +69,9 @@ func generateReadmeDocs(readmePath string) error { // Create toolset group with mock clients repoAccessCache := lockdown.GetInstance(nil) - tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000, github.FeatureFlags{}, repoAccessCache) + nilLogger := log.NewNoopLogger() + nilObsv := observability.NewExporters(nilLogger) + tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000, github.FeatureFlags{}, repoAccessCache, nilObsv) // Generate toolsets documentation toolsetsDoc := generateToolsetsDoc(tsg) @@ -307,7 +311,9 @@ func generateRemoteToolsetsDoc() string { // Create toolset group with mock clients repoAccessCache := lockdown.GetInstance(nil) - tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000, github.FeatureFlags{}, repoAccessCache) + nilLogger := log.NewNoopLogger() + nilObsv := observability.NewExporters(nilLogger) + tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000, github.FeatureFlags{}, repoAccessCache, nilObsv) // Generate table header buf.WriteString("| Name | Description | API URL | 1-Click Install (VS Code) | Read-only Link | 1-Click Read-only Install (VS Code) |\n") From 9af271aa77d4b24792ea47fafdbf9fb7c0e7c274 Mon Sep 17 00:00:00 2001 From: Adam Holt Date: Thu, 11 Dec 2025 15:24:40 +0100 Subject: [PATCH 4/4] Nothing is used here, so we can ignore the parameters for linter issues. --- pkg/observability/log/noop_adapter.go | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/pkg/observability/log/noop_adapter.go b/pkg/observability/log/noop_adapter.go index 391efd44e..eab44eda8 100644 --- a/pkg/observability/log/noop_adapter.go +++ b/pkg/observability/log/noop_adapter.go @@ -17,43 +17,43 @@ func (l *NoopLogger) Level() Level { return DebugLevel } -func (l *NoopLogger) Log(ctx context.Context, level Level, msg string, fields ...slog.Attr) { +func (l *NoopLogger) Log(_ context.Context, _ Level, _ string, _ ...slog.Attr) { // No-op } -func (l *NoopLogger) Debug(msg string, fields ...slog.Attr) { +func (l *NoopLogger) Debug(_ string, _ ...slog.Attr) { // No-op } -func (l *NoopLogger) Info(msg string, fields ...slog.Attr) { +func (l *NoopLogger) Info(_ string, _ ...slog.Attr) { // No-op } -func (l *NoopLogger) Warn(msg string, fields ...slog.Attr) { +func (l *NoopLogger) Warn(_ string, _ ...slog.Attr) { // No-op } -func (l *NoopLogger) Error(msg string, fields ...slog.Attr) { +func (l *NoopLogger) Error(_ string, _ ...slog.Attr) { // No-op } -func (l *NoopLogger) Fatal(msg string, fields ...slog.Attr) { +func (l *NoopLogger) Fatal(_ string, _ ...slog.Attr) { // No-op } -func (l *NoopLogger) WithFields(fields ...slog.Attr) Logger { +func (l *NoopLogger) WithFields(_ ...slog.Attr) Logger { return l } -func (l *NoopLogger) WithError(err error) Logger { +func (l *NoopLogger) WithError(_ error) Logger { return l } -func (l *NoopLogger) Named(name string) Logger { +func (l *NoopLogger) Named(_ string) Logger { return l } -func (l *NoopLogger) WithLevel(level Level) Logger { +func (l *NoopLogger) WithLevel(_ Level) Logger { return l }